Error code standardization

2025-08-18 18:39:51 +08:00 · 2023-01-03 15:17:33 +08:00 · 2023-01-03 15:17:33 +08:00 · a76e93626d
commit a76e93626d
parent 5e5d238e82
1 changed files with 108 additions and 0 deletions
--- a/internal/api_to_rpc/api.go
+++ b/internal/api_to_rpc/api.go
@ -0,0 +1,108 @@
+package common
+
+import (
+	"Open_IM/internal/fault_tolerant"
+	"context"
+	"examination/pkg/api_struct"
+	"examination/pkg/trace_log"
+	utils "github.com/OpenIMSDK/open_utils"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"reflect"
+)
+
+func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn interface{}, rpcFuncName string, tokenFunc func(token string) (string, error)) {
+	nCtx := trace_log.NewCtx(c, rpcFuncName)
+	defer trace_log.ShowLog(nCtx)
+	if err := c.BindJSON(apiReq); err != nil {
+		trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
+		return
+	}
+	reqValue := reflect.ValueOf(apiReq).Elem()
+	operationID := reqValue.FieldByName("OperationID").String()
+	trace_log.SetOperationID(nCtx, operationID)
+
+	trace_log.SetContextInfo(nCtx, "BindJSON", nil, "params", apiReq)
+
+	etcdConn, err := fault_tolerant.GetDefaultConn(rpcName, operationID)
+	if err != nil {
+		trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err)
+		return
+	}
+	rpc := reflect.ValueOf(fn).Call([]reflect.Value{
+		reflect.ValueOf(etcdConn),
+	})[0].MethodByName(rpcFuncName) // rpc func
+	rpcReqPtr := reflect.New(rpc.Type().In(1).Elem()) // *req参数
+	var opUserID string
+	if tokenFunc != nil {
+		var err error
+		opUserID, err = tokenFunc(c.GetHeader("token"))
+		if err != nil {
+			trace_log.WriteErrorResponse(nCtx, "TokenFunc", err)
+			return
+		}
+	}
+	if opID := rpcReqPtr.Elem().FieldByName("OperationID"); opID.IsValid() {
+		opID.SetString(operationID)
+		if opU := rpcReqPtr.Elem().FieldByName("OpUserID"); opU.IsValid() {
+			opU.SetString(opUserID)
+		}
+	} else {
+		op := rpcReqPtr.Elem().FieldByName("Operation").Elem()
+		op.FieldByName("OperationID").SetString(operationID)
+		op.FieldByName("OpUserID").SetString(opUserID)
+	}
+	if err := utils.CopyStructFields(rpcReqPtr.Interface(), apiReq); err != nil {
+		trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
+		return
+	}
+	respArr := rpc.Call([]reflect.Value{
+		reflect.ValueOf(context.Context(c)), // context.Context
+		rpcReqPtr,                           // rpc apiReq
+	}) // respArr => (apiResp, error)
+	if !respArr[1].IsNil() { // rpc err != nil
+		err := respArr[1].Interface().(error)
+		trace_log.WriteErrorResponse(nCtx, rpcFuncName, err, "rpc req", rpcReqPtr.Interface())
+		return
+	}
+	rpcResp := respArr[0].Elem()
+	trace_log.SetContextInfo(nCtx, rpcFuncName, nil, "rpc req", rpcReqPtr.Interface(), "resp", rpcResp.Interface())
+	commonResp := rpcResp.FieldByName("CommonResp").Elem()
+	errCodeVal := commonResp.FieldByName("ErrCode")
+	errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string)
+	errCode := errCodeVal.Interface().(int32)
+	if errCode != 0 {
+		trace_log.WriteErrorResponse(nCtx, "RpcErrCode", &api_struct.ErrInfo{
+			ErrCode: errCode,
+			ErrMsg:  errMsgVal,
+		})
+		return
+	}
+	if apiResp != nil {
+		if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil {
+			trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcResp", err)
+			return
+		}
+	}
+	trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
+}
+
+func WriteDataJson(c *gin.Context, code int32, msg string, data interface{}) {
+	c.JSON(http.StatusOK, &BaseResp{
+		ErrCode: code,
+		ErrMsg:  msg,
+		Data:    data,
+	})
+}
+
+//func WriteErr(c *gin.Context, err error) {
+//	if cerr, ok := err.(interface{ Code() int32 }); ok {
+//		WriteDataJson(c, cerr.Code(), err.Error(), nil)
+//	} else {
+//		WriteDataJson(c, ErrDefault.ErrCode, err.Error(), nil)
+//	}
+//}
+
+func WriteSuccess(c *gin.Context, msg string, data interface{}) {
+	WriteDataJson(c, 0, msg, data)
+}