Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

# Conflicts:
#	cmd/cmdutils/main.go

internal/api/a2r/api2rpc.go

@@ -2,7 +2,7 @@ package a2r
 
 import (
 	"OpenIM/internal/apiresp"
-	"OpenIM/pkg/common/constant"
+	"OpenIM/pkg/errs"
 	"context"
 	"github.com/gin-gonic/gin"
 	"google.golang.org/grpc"
@@ -15,18 +15,18 @@ func Call[A, B, C any](
 ) {
 	var req A
 	if err := c.BindJSON(&req); err != nil {
-		apiresp.GinError(c, constant.ErrArgs.Wrap(err.Error())) // 参数错误
+		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error())) // 参数错误
 		return
 	}
 	if check, ok := any(&req).(interface{ Check() error }); ok {
 		if err := check.Check(); err != nil {
-			apiresp.GinError(c, constant.ErrArgs.Wrap(err.Error())) // 参数校验失败
+			apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error())) // 参数校验失败
 			return
 		}
 	}
 	cli, err := client()
 	if err != nil {
-		apiresp.GinError(c, constant.ErrInternalServer.Wrap(err.Error())) // 获取RPC连接失败
+		apiresp.GinError(c, errs.ErrInternalServer.Wrap(err.Error())) // 获取RPC连接失败
 		return
 	}
 	data, err := rpc(cli, c, &req)

internal/api/auth.go

@@ -20,7 +20,7 @@ type Auth struct {
 }
 
 func (o *Auth) client() (auth.AuthClient, error) {
-	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName, nil)
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImAuthName)
 	if err != nil {
 		return nil, err
 	}

internal/api/conversation.go

@@ -20,7 +20,7 @@ type Conversation struct {
 }
 
 func (o *Conversation) client() (conversation.ConversationClient, error) {
-	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImConversationName)
 	if err != nil {
 		return nil, err
 	}

internal/api/friend.go

@@ -20,7 +20,7 @@ type Friend struct {
 }
 
 func (o *Friend) client() (friend.FriendClient, error) {
-	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImFriendName)
 	if err != nil {
 		return nil, err
 	}

internal/api/msg.go

@@ -7,6 +7,7 @@ import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/constant"
 	"OpenIM/pkg/common/log"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/msg"
 	"OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
@@ -192,22 +193,22 @@ func (o *Msg) ManagementSendMsg(c *gin.Context) {
 		return
 	}
 	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
-		apiresp.GinError(c, constant.ErrData)
+		apiresp.GinError(c, errs.ErrData)
 		return
 	} else if err := o.validate.Struct(data); err != nil {
-		apiresp.GinError(c, constant.ErrData)
+		apiresp.GinError(c, errs.ErrData)
 		return
 	}
 	log.NewInfo(params.OperationID, data, params)
 	switch params.SessionType {
 	case constant.SingleChatType:
 		if len(params.RecvID) == 0 {
-			apiresp.GinError(c, constant.ErrData)
+			apiresp.GinError(c, errs.ErrData)
 			return
 		}
 	case constant.GroupChatType, constant.SuperGroupChatType:
 		if len(params.GroupID) == 0 {
-			apiresp.GinError(c, constant.ErrData)
+			apiresp.GinError(c, errs.ErrData)
 			return
 		}
 	}
@@ -215,7 +216,7 @@ func (o *Msg) ManagementSendMsg(c *gin.Context) {
 	pbData := newUserSendMsgReq(&params)
 	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
 	if err != nil {
-		apiresp.GinError(c, constant.ErrInternalServer)
+		apiresp.GinError(c, errs.ErrInternalServer)
 		return
 	}
 	client := msg.NewMsgClient(conn)

internal/api/route.go

@@ -3,7 +3,7 @@ package api
 import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/middleware"
+	"OpenIM/pkg/common/mw"
 	"OpenIM/pkg/common/prome"
 	"github.com/OpenIMSDK/openKeeper"
 	"github.com/gin-gonic/gin"
@@ -11,15 +11,14 @@ import (
 	"os"
 )
 
-func NewGinRouter() *gin.Engine {
+func NewGinRouter(zk *openKeeper.ZkClient) *gin.Engine {
 	gin.SetMode(gin.ReleaseMode)
 	f, _ := os.Create("../logs/api.log")
 	gin.DefaultWriter = io.MultiWriter(f)
 	//	gin.SetMode(gin.DebugMode)
 	r := gin.New()
-	r.Use(gin.Recovery())
-	r.Use(middleware.GinParseOperationID)
 	log.Info("load config: ", config.Config)
+	r.Use(gin.Recovery(), mw.CorsHandler(), mw.GinParseOperationID())
 	if config.Config.Prometheus.Enable {
 		prome.NewApiRequestCounter()
 		prome.NewApiRequestFailedCounter()
@@ -27,8 +26,7 @@ func NewGinRouter() *gin.Engine {
 		r.Use(prome.PrometheusMiddleware)
 		r.GET("/metrics", prome.PrometheusHandler())
 	}
-
-	var zk *openKeeper.ZkClient
+	zk.AddOption(mw.GrpcClient()) // 默认RPC中间件
 
 	userRouterGroup := r.Group("/user")
 	{
@@ -148,25 +146,3 @@ func NewGinRouter() *gin.Engine {
 	}
 	return r
 }
-
-/*
-
-	{
-		GetSeq
-		SendMsg
-		PullMsgBySeqList
-		DelMsg
-		DelSuperGroupMsg
-		ClearMsg
-		SetMsgMinSeq
-		SetMessageReactionExtensions
-		GetMessageListReactionExtensions
-		AddMessageReactionExtensions
-		DeleteMessageReactionExtensions
-		ManagementSendMsg
-		ManagementBatchSendMsg
-		CheckMsgIsSendSuccess
-	}
-
-
-*/

internal/api/user.go

@@ -20,7 +20,7 @@ type User struct {
 }
 
 func (o *User) client() (user.UserClient, error) {
-	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
+	conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImUserName)
 	if err != nil {
 		return nil, err
 	}
@@ -47,7 +47,6 @@ func (o *User) GetAllUsersID(c *gin.Context) {
 	a2r.Call(user.UserClient.GetDesignateUsers, o.client, c)
 }
 
-//
 func (u *User) AccountCheck(c *gin.Context) {
 	a2r.Call(user.UserClient.AccountCheck, u.client, c)
 }

internal/common/check/friend.go

@@ -4,6 +4,7 @@ import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/constant"
 	discoveryRegistry "OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/friend"
 	sdkws "OpenIM/pkg/proto/sdkws"
 	"context"
@@ -67,7 +68,7 @@ func (f *FriendChecker) GetAllPageFriends(ctx context.Context, ownerUserID strin
 			if tmp.Total == int32(len(resp)) {
 				return resp, nil
 			}
-			return nil, constant.ErrData.Wrap("The total number of results and expectations are different, but result is nil")
+			return nil, errs.ErrData.Wrap("The total number of results and expectations are different, but result is nil")
 		}
 		resp = append(resp, tmp.FriendsInfo...)
 		page++

internal/common/check/group.go

@@ -4,6 +4,7 @@ import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/constant"
 	discoveryRegistry "OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/group"
 	sdkws "OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
@@ -41,7 +42,7 @@ func (g *GroupChecker) GetGroupInfos(ctx context.Context, groupIDs []string, com
 		if ids := utils.Single(groupIDs, utils.Slice(resp.GroupInfos, func(e *sdkws.GroupInfo) string {
 			return e.GroupID
 		})); len(ids) > 0 {
-			return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
+			return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
 		}
 	}
 	return resp.GroupInfos, nil
@@ -81,7 +82,7 @@ func (g *GroupChecker) GetGroupMemberInfos(ctx context.Context, groupID string,
 		if ids := utils.Single(userIDs, utils.Slice(resp.Members, func(e *sdkws.GroupMemberFullInfo) string {
 			return e.UserID
 		})); len(ids) > 0 {
-			return nil, constant.ErrNotInGroupYet.Wrap(strings.Join(ids, ","))
+			return nil, errs.ErrNotInGroupYet.Wrap(strings.Join(ids, ","))
 		}
 	}
 	return resp.Members, nil

internal/common/check/user.go

@@ -2,8 +2,8 @@ package check
 
 import (
 	"OpenIM/pkg/common/config"
-	"OpenIM/pkg/common/constant"
 	"OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/proto/user"
 	"OpenIM/pkg/utils"
@@ -41,7 +41,7 @@ func (u *UserCheck) GetUsersInfos(ctx context.Context, userIDs []string, complet
 		if ids := utils.Single(userIDs, utils.Slice(resp.UsersInfo, func(e *sdkws.UserInfo) string {
 			return e.UserID
 		})); len(ids) > 0 {
-			return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
+			return nil, errs.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
 		}
 	}
 	return resp.UsersInfo, nil

internal/msggateway/batch_push.go

@@ -1,14 +1,12 @@
 package msggateway
 
 import (
-	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/log"
 	pbChat "OpenIM/pkg/proto/msg"
 	sdkws "OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
 	"context"
 	"google.golang.org/grpc"
-	"strings"
 )
 
 var MaxPullMsgNum = 100

internal/msggateway/new/http_error.go

@@ -1,7 +1,7 @@
 package new
 
 import (
-	"OpenIM/pkg/common/constant"
+	"OpenIM/pkg/errs"
 	"errors"
 	"net/http"
 )
@@ -10,35 +10,35 @@ func httpError(ctx *UserConnContext, err error) {
 	code := http.StatusUnauthorized
 	ctx.SetHeader("Sec-Websocket-Version", "13")
 	ctx.SetHeader("ws_err_msg", err.Error())
-	if errors.Is(err, constant.ErrTokenExpired) {
-		code = int(constant.ErrTokenExpired.ErrCode)
+	if errors.Is(err, errs.ErrTokenExpired) {
+		code = errs.ErrTokenExpired.Code()
 	}
-	if errors.Is(err, constant.ErrTokenInvalid) {
-		code = int(constant.ErrTokenInvalid.ErrCode)
+	if errors.Is(err, errs.ErrTokenInvalid) {
+		code = errs.ErrTokenInvalid.Code()
 	}
-	if errors.Is(err, constant.ErrTokenMalformed) {
-		code = int(constant.ErrTokenMalformed.ErrCode)
+	if errors.Is(err, errs.ErrTokenMalformed) {
+		code = errs.ErrTokenMalformed.Code()
 	}
-	if errors.Is(err, constant.ErrTokenNotValidYet) {
-		code = int(constant.ErrTokenNotValidYet.ErrCode)
+	if errors.Is(err, errs.ErrTokenNotValidYet) {
+		code = errs.ErrTokenNotValidYet.Code()
 	}
-	if errors.Is(err, constant.ErrTokenUnknown) {
-		code = int(constant.ErrTokenUnknown.ErrCode)
+	if errors.Is(err, errs.ErrTokenUnknown) {
+		code = errs.ErrTokenUnknown.Code()
 	}
-	if errors.Is(err, constant.ErrTokenKicked) {
-		code = int(constant.ErrTokenKicked.ErrCode)
+	if errors.Is(err, errs.ErrTokenKicked) {
+		code = errs.ErrTokenKicked.Code()
 	}
-	if errors.Is(err, constant.ErrTokenDifferentPlatformID) {
-		code = int(constant.ErrTokenDifferentPlatformID.ErrCode)
+	if errors.Is(err, errs.ErrTokenDifferentPlatformID) {
+		code = errs.ErrTokenDifferentPlatformID.Code()
 	}
-	if errors.Is(err, constant.ErrTokenDifferentUserID) {
-		code = int(constant.ErrTokenDifferentUserID.ErrCode)
+	if errors.Is(err, errs.ErrTokenDifferentUserID) {
+		code = errs.ErrTokenDifferentUserID.Code()
 	}
-	if errors.Is(err, constant.ErrConnOverMaxNumLimit) {
-		code = int(constant.ErrConnOverMaxNumLimit.ErrCode)
+	if errors.Is(err, errs.ErrConnOverMaxNumLimit) {
+		code = errs.ErrConnOverMaxNumLimit.Code()
 	}
-	if errors.Is(err, constant.ErrConnArgsErr) {
-		code = int(constant.ErrConnArgsErr.ErrCode)
+	if errors.Is(err, errs.ErrConnArgsErr) {
+		code = errs.ErrConnArgsErr.Code()
 	}
 	ctx.ErrReturn(err.Error(), code)
 }

internal/msggateway/new/n_ws_server.go

@@ -3,6 +3,7 @@ package new
 import (
 	"OpenIM/pkg/common/constant"
 	"OpenIM/pkg/common/tokenverify"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/utils"
 	"errors"
 	"fmt"
@@ -131,7 +132,7 @@ func (ws *WsServer) unregisterClient(client *Client) {
 func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 	context := newContext(w, r)
 	if ws.onlineUserConnNum >= ws.wsMaxConnNum {
-		httpError(context, constant.ErrConnOverMaxNumLimit)
+		httpError(context, errs.ErrConnOverMaxNumLimit)
 		return
 	}
 	var (
@@ -145,17 +146,17 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 
 	token, exists = context.Query(TOKEN)
 	if !exists {
-		httpError(context, constant.ErrConnArgsErr)
+		httpError(context, errs.ErrConnArgsErr)
 		return
 	}
 	userID, exists = context.Query(WS_USERID)
 	if !exists {
-		httpError(context, constant.ErrConnArgsErr)
+		httpError(context, errs.ErrConnArgsErr)
 		return
 	}
 	platformID, exists = context.Query(PLATFORM_ID)
 	if !exists {
-		httpError(context, constant.ErrConnArgsErr)
+		httpError(context, errs.ErrConnArgsErr)
 		return
 	}
 	err := tokenverify.WsVerifyToken(token, userID, platformID)

internal/msggateway/relay_rpc_server.go

@@ -143,7 +143,7 @@ func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *msggateway.GetU
 	log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
 	if !tokenverify.IsManagerUserID(req.OpUserID) {
 		log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
-		return &msggateway.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+		return &msggateway.GetUsersOnlineStatusResp{ErrCode: errs.ErrAccess.ErrCode, ErrMsg: errs.ErrAccess.ErrMsg}, nil
 	}
 	var resp msggateway.GetUsersOnlineStatusResp
 	for _, userID := range req.UserIDList {

internal/msggateway/ws_server.go

@@ -6,6 +6,7 @@ import (
 	"OpenIM/pkg/common/log"
 	"OpenIM/pkg/common/prome"
 	"OpenIM/pkg/common/tokenverify"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/msggateway"
 	"OpenIM/pkg/utils"
 	"bytes"
@@ -303,8 +304,8 @@ func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int, newConn
 func (ws *WServer) sendKickMsg(oldConn *UserConn) {
 	mReply := Resp{
 		ReqIdentifier: constant.WSKickOnlineMsg,
-		ErrCode:       constant.ErrTokenInvalid.ErrCode,
-		ErrMsg:        constant.ErrTokenInvalid.ErrMsg,
+		ErrCode:       int32(errs.ErrTokenInvalid.Code()),
+		ErrMsg:        errs.ErrTokenInvalid.Msg(),
 	}
 	var b bytes.Buffer
 	enc := gob.NewEncoder(&b)
@@ -443,47 +444,47 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operation
 	query := r.URL.Query()
 	if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
 		if ok, err, msg := tokenverify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok {
-			if errors.Is(err, constant.ErrTokenExpired) {
-				status = int(constant.ErrTokenExpired.ErrCode)
+			if errors.Is(err, errs.ErrTokenExpired) {
+				status = int(errs.ErrTokenExpired.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenInvalid) {
-				status = int(constant.ErrTokenInvalid.ErrCode)
+			if errors.Is(err, errs.ErrTokenInvalid) {
+				status = int(errs.ErrTokenInvalid.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenMalformed) {
-				status = int(constant.ErrTokenMalformed.ErrCode)
+			if errors.Is(err, errs.ErrTokenMalformed) {
+				status = int(errs.ErrTokenMalformed.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenNotValidYet) {
-				status = int(constant.ErrTokenNotValidYet.ErrCode)
+			if errors.Is(err, errs.ErrTokenNotValidYet) {
+				status = int(errs.ErrTokenNotValidYet.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenUnknown) {
-				status = int(constant.ErrTokenUnknown.ErrCode)
+			if errors.Is(err, errs.ErrTokenUnknown) {
+				status = int(errs.ErrTokenUnknown.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenKicked) {
-				status = int(constant.ErrTokenKicked.ErrCode)
+			if errors.Is(err, errs.ErrTokenKicked) {
+				status = int(errs.ErrTokenKicked.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenDifferentPlatformID) {
-				status = int(constant.ErrTokenDifferentPlatformID.ErrCode)
+			if errors.Is(err, errs.ErrTokenDifferentPlatformID) {
+				status = int(errs.ErrTokenDifferentPlatformID.ErrCode)
 			}
-			if errors.Is(err, constant.ErrTokenDifferentUserID) {
-				status = int(constant.ErrTokenDifferentUserID.ErrCode)
+			if errors.Is(err, errs.ErrTokenDifferentUserID) {
+				status = int(errs.ErrTokenDifferentUserID.ErrCode)
 			}
 			//switch errors.Cause(err) {
-			//case constant.ErrTokenExpired:
-			//	status = int(constant.ErrTokenExpired.ErrCode)
-			//case constant.ErrTokenInvalid:
-			//	status = int(constant.ErrTokenInvalid.ErrCode)
-			//case constant.ErrTokenMalformed:
-			//	status = int(constant.ErrTokenMalformed.ErrCode)
-			//case constant.ErrTokenNotValidYet:
-			//	status = int(constant.ErrTokenNotValidYet.ErrCode)
-			//case constant.ErrTokenUnknown:
-			//	status = int(constant.ErrTokenUnknown.ErrCode)
-			//case constant.ErrTokenKicked:
-			//	status = int(constant.ErrTokenKicked.ErrCode)
-			//case constant.ErrTokenDifferentPlatformID:
-			//	status = int(constant.ErrTokenDifferentPlatformID.ErrCode)
-			//case constant.ErrTokenDifferentUserID:
-			//	status = int(constant.ErrTokenDifferentUserID.ErrCode)
+			//case errs.ErrTokenExpired:
+			//	status = int(errs.ErrTokenExpired.ErrCode)
+			//case errs.ErrTokenInvalid:
+			//	status = int(errs.ErrTokenInvalid.ErrCode)
+			//case errs.ErrTokenMalformed:
+			//	status = int(errs.ErrTokenMalformed.ErrCode)
+			//case errs.ErrTokenNotValidYet:
+			//	status = int(errs.ErrTokenNotValidYet.ErrCode)
+			//case errs.ErrTokenUnknown:
+			//	status = int(errs.ErrTokenUnknown.ErrCode)
+			//case errs.ErrTokenKicked:
+			//	status = int(errs.ErrTokenKicked.ErrCode)
+			//case errs.ErrTokenDifferentPlatformID:
+			//	status = int(errs.ErrTokenDifferentPlatformID.ErrCode)
+			//case errs.ErrTokenDifferentUserID:
+			//	status = int(errs.ErrTokenDifferentUserID.ErrCode)
 			//}
 
 			log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error(), "status: ", status)
@@ -502,7 +503,7 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operation
 			return true, compression
 		}
 	} else {
-		status = int(constant.ErrArgs.ErrCode)
+		status = int(errs.ErrArgs.ErrCode)
 		log.Error(operationID, "Args err ", "query ", query)
 		w.Header().Set("Sec-Websocket-Version", "13")
 		errMsg := "args err, need token, sendID, platformID"

internal/push/push_to_client.go

@@ -20,6 +20,7 @@ import (
 	"OpenIM/pkg/common/prome"
 	"OpenIM/pkg/common/tracelog"
 	"OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/msggateway"
 	"OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
@@ -67,7 +68,7 @@ func (p *Pusher) MsgToUser(ctx context.Context, userID string, msg *sdkws.MsgDat
 	var userIDs = []string{userID}
 	log.Debug(operationID, "Get msg from msg_transfer And push msg", msg.String(), userID)
 	// callback
-	if err := callbackOnlinePush(ctx, userIDs, msg); err != nil && err != constant.ErrCallbackContinue {
+	if err := callbackOnlinePush(ctx, userIDs, msg); err != nil && err != errs.ErrCallbackContinue {
 		return err
 	}
 	// push
@@ -110,7 +111,7 @@ func (p *Pusher) MsgToSuperGroupUser(ctx context.Context, groupID string, msg *s
 	operationID := tracelog.GetOperationID(ctx)
 	log.Debug(operationID, "Get super group msg from msg_transfer And push msg", msg.String(), groupID)
 	var pushToUserIDs []string
-	if err := callbackBeforeSuperGroupOnlinePush(ctx, groupID, msg, &pushToUserIDs); err != nil && err != constant.ErrCallbackContinue {
+	if err := callbackBeforeSuperGroupOnlinePush(ctx, groupID, msg, &pushToUserIDs); err != nil && err != errs.ErrCallbackContinue {
 		return err
 	}
 	if len(pushToUserIDs) == 0 {

internal/rpc/auth/auth.go

@@ -10,6 +10,7 @@ import (
 	"OpenIM/pkg/common/tokenverify"
 	"OpenIM/pkg/common/tracelog"
 	discoveryRegistry "OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	pbAuth "OpenIM/pkg/proto/auth"
 	"OpenIM/pkg/proto/msggateway"
 	"OpenIM/pkg/utils"
@@ -60,19 +61,19 @@ func (s *authServer) parseToken(ctx context.Context, tokensString string) (claim
 		return nil, err
 	}
 	if len(m) == 0 {
-		return nil, constant.ErrTokenNotExist.Wrap()
+		return nil, errs.ErrTokenNotExist.Wrap()
 	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
 		case constant.NormalToken:
 			return claims, nil
 		case constant.KickedToken:
-			return nil, constant.ErrTokenKicked.Wrap()
+			return nil, errs.ErrTokenKicked.Wrap()
 		default:
-			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
+			return nil, utils.Wrap(errs.ErrTokenUnknown, "")
 		}
 	}
-	return nil, constant.ErrTokenNotExist.Wrap()
+	return nil, errs.ErrTokenNotExist.Wrap()
 }
 
 func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
@@ -110,5 +111,5 @@ func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID
 		_, err := client.KickUserOffline(ctx, kickReq)
 		return utils.Wrap(err, "")
 	}
-	return constant.ErrInternalServer.Wrap()
+	return errs.ErrInternalServer.Wrap()
 }

internal/rpc/friend/friend.go

@@ -12,6 +12,7 @@ import (
 	"OpenIM/pkg/common/tokenverify"
 	"OpenIM/pkg/common/tracelog"
 	registry "OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	pbfriend "OpenIM/pkg/proto/friend"
 	"OpenIM/pkg/utils"
 	"context"
@@ -50,11 +51,11 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
-	if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 	if req.ToUserID == req.FromUserID {
-		return nil, constant.ErrCanNotAddYourself.Wrap()
+		return nil, errs.ErrCanNotAddYourself.Wrap()
 	}
 	if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil {
 		return nil, err
@@ -64,7 +65,7 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
 		return nil, err
 	}
 	if in1 && in2 {
-		return nil, constant.ErrRelationshipAlready.Wrap()
+		return nil, errs.ErrRelationshipAlready.Wrap()
 	}
 	if err = s.FriendDatabase.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
 		return nil, err
@@ -84,10 +85,10 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFr
 	}
 
 	if utils.Contain(req.OwnerUserID, req.FriendUserIDs...) {
-		return nil, constant.ErrCanNotAddYourself.Wrap()
+		return nil, errs.ErrCanNotAddYourself.Wrap()
 	}
 	if utils.Duplicate(req.FriendUserIDs) {
-		return nil, constant.ErrArgs.Wrap("friend userID repeated")
+		return nil, errs.ErrArgs.Wrap("friend userID repeated")
 	}
 
 	if err := s.FriendDatabase.BecomeFriends(ctx, req.OwnerUserID, req.FriendUserIDs, constant.BecomeFriendByImport, tracelog.GetOpUserID(ctx)); err != nil {
@@ -119,7 +120,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.Res
 		s.notification.FriendApplicationRefusedNotification(ctx, req)
 		return resp, nil
 	}
-	return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1")
+	return nil, errs.ErrArgs.Wrap("req.HandleResult != -1/1")
 }
 
 // ok
@@ -162,7 +163,7 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.G
 	resp = &pbfriend.GetDesignatedFriendsResp{}
 
 	if utils.Duplicate(req.FriendUserIDs) {
-		return nil, constant.ErrArgs.Wrap("friend userID repeated")
+		return nil, errs.ErrArgs.Wrap("friend userID repeated")
 	}
 	friends, err := s.FriendDatabase.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
 	if err != nil {

internal/rpc/group/group.go

@@ -12,6 +12,7 @@ import (
 	"OpenIM/pkg/common/tokenverify"
 	"OpenIM/pkg/common/tracelog"
 	"OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	pbConversation "OpenIM/pkg/proto/conversation"
 	pbGroup "OpenIM/pkg/proto/group"
 	"OpenIM/pkg/proto/sdkws"
@@ -65,7 +66,7 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 			return err
 		}
 		if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
-			return constant.ErrNoPermission.Wrap("no group owner or admin")
+			return errs.ErrNoPermission.Wrap("no group owner or admin")
 		}
 	}
 	return nil
@@ -92,7 +93,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 	if *groupID != "" {
 		_, err := s.GroupDatabase.TakeGroup(ctx, *groupID)
 		if err == nil {
-			return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
+			return errs.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
 		} else if s.IsNotFound(err) {
 			return nil
 		} else {
@@ -114,7 +115,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 			return err
 		}
 	}
-	return constant.ErrData.Wrap("group id gen error")
+	return errs.ErrData.Wrap("group id gen error")
 }
 
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
@@ -123,17 +124,17 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		return nil, err
 	}
 	if req.OwnerUserID == "" {
-		return nil, constant.ErrArgs.Wrap("no group owner")
+		return nil, errs.ErrArgs.Wrap("no group owner")
 	}
 	userIDs := append(append(req.InitMembers, req.AdminUserIDs...), req.OwnerUserID)
 	if utils.Duplicate(userIDs) {
-		return nil, constant.ErrArgs.Wrap("group member repeated")
+		return nil, errs.ErrArgs.Wrap("group member repeated")
 	}
 	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 	var groupMembers []*relationTb.GroupMemberModel
@@ -149,7 +150,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 			return err
 		}
 		groupMembers = append(groupMembers, groupMember)
@@ -233,17 +234,17 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
 	resp := &pbGroup.InviteUserToGroupResp{}
 	if len(req.InvitedUserIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("user empty")
+		return nil, errs.ErrArgs.Wrap("user empty")
 	}
 	if utils.Duplicate(req.InvitedUserIDs) {
-		return nil, constant.ErrArgs.Wrap("userID duplicate")
+		return nil, errs.ErrArgs.Wrap("userID duplicate")
 	}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
-		return nil, constant.ErrDismissedAlready.Wrap()
+		return nil, errs.ErrDismissedAlready.Wrap()
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{group.GroupID}, nil, nil)
 	if err != nil {
@@ -253,7 +254,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		return e.UserID
 	})
 	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
-		return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
+		return nil, errs.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
 	}
 	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
 	if err != nil {
@@ -264,7 +265,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			opUserID := tracelog.GetOpUserID(ctx)
 			member, ok := memberMap[opUserID]
 			if !ok {
-				return nil, constant.ErrNoPermission.Wrap("not in group")
+				return nil, errs.ErrNoPermission.Wrap("not in group")
 			}
 			if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
 				var requests []*relationTb.GroupRequestModel
@@ -309,7 +310,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			member.OperatorUserID = opUserID
 			member.InviterUserID = opUserID
 			member.JoinSource = constant.JoinByInvitation
-			if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue {
+			if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 				return nil, err
 			}
 			groupMembers = append(groupMembers, member)
@@ -329,7 +330,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 		return nil, err
 	}
 	if group.GroupType == constant.SuperGroup {
-		return nil, constant.ErrArgs.Wrap("unsupported super group")
+		return nil, errs.ErrArgs.Wrap("unsupported super group")
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, nil)
 	if err != nil {
@@ -379,14 +380,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		return nil, err
 	}
 	if len(req.KickedUserIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("KickedUserIDs empty")
+		return nil, errs.ErrArgs.Wrap("KickedUserIDs empty")
 	}
 	if utils.IsDuplicateStringSlice(req.KickedUserIDs) {
-		return nil, constant.ErrArgs.Wrap("KickedUserIDs duplicate")
+		return nil, errs.ErrArgs.Wrap("KickedUserIDs duplicate")
 	}
 	opUserID := tracelog.GetOpUserID(ctx)
 	if utils.IsContain(opUserID, req.KickedUserIDs) {
-		return nil, constant.ErrArgs.Wrap("opUserID in KickedUserIDs")
+		return nil, errs.ErrArgs.Wrap("opUserID in KickedUserIDs")
 	}
 	if group.GroupType == constant.SuperGroup {
 		if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, req.KickedUserIDs); err != nil {
@@ -408,13 +409,13 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		}
 		for _, userID := range req.KickedUserIDs {
 			if _, ok := memberMap[userID]; !ok {
-				return nil, constant.ErrUserIDNotFound.Wrap(userID)
+				return nil, errs.ErrUserIDNotFound.Wrap(userID)
 			}
 		}
 		if !tokenverify.IsAppManagerUid(ctx) {
 			member := memberMap[opUserID]
 			if member == nil {
-				return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
+				return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
 			}
 			switch member.RoleLevel {
 			case constant.GroupOwner:
@@ -424,11 +425,11 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 						continue
 					}
 					if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
-						return nil, constant.ErrNoPermission.Wrap("userID:" + member.UserID)
+						return nil, errs.ErrNoPermission.Wrap("userID:" + member.UserID)
 					}
 				}
 			default:
-				return nil, constant.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
+				return nil, errs.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
 			}
 		}
 		if err := s.GroupDatabase.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
@@ -442,10 +443,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
 	resp := &pbGroup.GetGroupMembersInfoResp{}
 	if len(req.Members) == 0 {
-		return nil, constant.ErrArgs.Wrap("members empty")
+		return nil, errs.ErrArgs.Wrap("members empty")
 	}
 	if req.GroupID == "" {
-		return nil, constant.ErrArgs.Wrap("groupID empty")
+		return nil, errs.ErrArgs.Wrap("groupID empty")
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, req.Members, nil)
 	if err != nil {
@@ -498,7 +499,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 		return e.GroupID
 	})
 	if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
-		return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
+		return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
 	}
 	groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
@@ -520,7 +521,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
 	resp := &pbGroup.GetGroupsInfoResp{}
 	if len(req.GroupIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("groupID is empty")
+		return nil, errs.ErrArgs.Wrap("groupID is empty")
 	}
 	groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
 	if err != nil {
@@ -546,7 +547,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
 func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
 	resp := &pbGroup.GroupApplicationResponseResp{}
 	if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
-		return nil, constant.ErrArgs.Wrap("HandleResult unknown")
+		return nil, errs.ErrArgs.Wrap("HandleResult unknown")
 	}
 	if !tokenverify.IsAppManagerUid(ctx) {
 		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID)
@@ -554,7 +555,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			return nil, err
 		}
 		if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
-			return nil, constant.ErrNoPermission.Wrap("no group owner or admin")
+			return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
 		}
 	}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
@@ -566,7 +567,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		return nil, err
 	}
 	if groupRequest.HandleResult != 0 {
-		return nil, constant.ErrArgs.Wrap("group request already processed")
+		return nil, errs.ErrArgs.Wrap("group request already processed")
 	}
 	var join bool
 	if _, err = s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
@@ -592,7 +593,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			OperatorUserID: tracelog.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
 		}
-		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue {
+		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 			return nil, err
 		}
 	}
@@ -620,11 +621,11 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
-		return nil, constant.ErrDismissedAlready.Wrap()
+		return nil, errs.ErrDismissedAlready.Wrap()
 	}
 	if group.NeedVerification == constant.Directly {
 		if group.GroupType == constant.SuperGroup {
-			return nil, constant.ErrGroupTypeNotSupport.Wrap()
+			return nil, errs.ErrGroupTypeNotSupport.Wrap()
 		}
 		user, err := s.UserCheck.GetUserInfo(ctx, tracelog.GetOpUserID(ctx))
 		if err != nil {
@@ -636,7 +637,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 			return nil, err
 		}
 		if err := s.GroupDatabase.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
@@ -688,7 +689,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 			return nil, err
 		}
 		if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
-			return nil, constant.ErrNoPermission.Wrap("no group owner or admin")
+			return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
 		}
 	}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
@@ -696,7 +697,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
-		return nil, utils.Wrap(constant.ErrDismissedAlready, "")
+		return nil, utils.Wrap(errs.ErrDismissedAlready, "")
 	}
 	userIDs, err := s.GroupDatabase.FindGroupMemberUserID(ctx, group.GroupID)
 	if err != nil {
@@ -739,10 +740,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
-		return nil, utils.Wrap(constant.ErrDismissedAlready, "")
+		return nil, utils.Wrap(errs.ErrDismissedAlready, "")
 	}
 	if req.OldOwnerUserID == req.NewOwnerUserID {
-		return nil, constant.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID")
+		return nil, errs.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID")
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{req.OldOwnerUserID, req.NewOwnerUserID}, nil)
 	if err != nil {
@@ -750,11 +751,11 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 	}
 	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string { return e.UserID })
 	if ids := utils.Single([]string{req.OldOwnerUserID, req.NewOwnerUserID}, utils.Keys(memberMap)); len(ids) > 0 {
-		return nil, constant.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
+		return nil, errs.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
 	}
 	newOwner := memberMap[req.NewOwnerUserID]
 	if newOwner == nil {
-		return nil, constant.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID)
+		return nil, errs.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID)
 	}
 	oldOwner := memberMap[req.OldOwnerUserID]
 	if tokenverify.IsAppManagerUid(ctx) {
@@ -766,10 +767,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 		}
 	} else {
 		if oldOwner == nil {
-			return nil, constant.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
+			return nil, errs.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
 		}
 		if oldOwner.GroupID != tracelog.GetOpUserID(ctx) {
-			return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
+			return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
 		}
 	}
 	if err := s.GroupDatabase.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
@@ -805,7 +806,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(ownerMemberMap)); len(ids) > 0 {
-		return nil, constant.ErrDB.Wrap("group not owner " + strings.Join(ids, ","))
+		return nil, errs.ErrDatabase.Wrap("group not owner " + strings.Join(ids, ","))
 	}
 	groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
@@ -865,7 +866,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 {
-		return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
+		return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
 	}
 	owners, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner})
 	if err != nil {
@@ -875,7 +876,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 		return e.GroupID
 	})
 	if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
-		return nil, constant.ErrData.Wrap("group no owner", strings.Join(ids, ","))
+		return nil, errs.ErrData.Wrap("group no owner", strings.Join(ids, ","))
 	}
 	groupMemberNum, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
@@ -897,7 +898,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 		return nil, err
 	}
 	if group.Status == constant.GroupStatusDismissed {
-		return nil, constant.ErrArgs.Wrap("group status is dismissed")
+		return nil, errs.ErrArgs.Wrap("group status is dismissed")
 	}
 	if err := s.GroupDatabase.DismissGroup(ctx, req.GroupID); err != nil {
 		return nil, err
@@ -924,7 +925,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 			return nil, err
 		}
 		if opMember.RoleLevel <= member.RoleLevel {
-			return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
+			return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
 		}
 	}
 	data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds)))
@@ -947,7 +948,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 			return nil, err
 		}
 		if opMember.RoleLevel <= member.RoleLevel {
-			return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
+			return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
 		}
 	}
 	data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0))
@@ -985,7 +986,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) {
 	resp := &pbGroup.SetGroupMemberInfoResp{}
 	if len(req.Members) == 0 {
-		return nil, constant.ErrArgs.Wrap("members empty")
+		return nil, errs.ErrArgs.Wrap("members empty")
 	}
 	duplicateMap := make(map[[2]string]struct{})
 	userIDMap := make(map[string]struct{})
@@ -993,7 +994,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 	for _, member := range req.Members {
 		key := [...]string{member.GroupID, member.UserID}
 		if _, ok := duplicateMap[key]; ok {
-			return nil, constant.ErrArgs.Wrap("group user duplicate")
+			return nil, errs.ErrArgs.Wrap("group user duplicate")
 		}
 		duplicateMap[key] = struct{}{}
 		userIDMap[member.UserID] = struct{}{}
@@ -1009,7 +1010,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		delete(duplicateMap, [...]string{member.GroupID, member.UserID})
 	}
 	if len(duplicateMap) > 0 {
-		return nil, constant.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
+		return nil, errs.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
 			return fmt.Sprintf("[group: %s user: %s]", e[0], e[1])
 		}), ","))
 	}
@@ -1024,10 +1025,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 			}
 			opMember, ok := memberMap[[...]string{member.GroupID, member.UserID}]
 			if !ok {
-				return nil, constant.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID))
+				return nil, errs.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID))
 			}
 			if member.RoleLevel >= opMember.RoleLevel {
-				return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel))
+				return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel))
 			}
 		}
 	}
@@ -1036,7 +1037,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 			continue
 		}
 		if memberMap[[...]string{member.GroupID, member.UserID}].RoleLevel == constant.GroupOwner {
-			return nil, constant.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID))
+			return nil, errs.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID))
 		}
 	}
 	for i := 0; i < len(req.Members); i++ {
@@ -1063,10 +1064,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) {
 	resp := &pbGroup.GetGroupAbstractInfoResp{}
 	if len(req.GroupIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("groupIDs empty")
+		return nil, errs.ErrArgs.Wrap("groupIDs empty")
 	}
 	if utils.Duplicate(req.GroupIDs) {
-		return nil, constant.ErrArgs.Wrap("groupIDs duplicate")
+		return nil, errs.ErrArgs.Wrap("groupIDs duplicate")
 	}
 	groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
 	if err != nil {
@@ -1075,14 +1076,14 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 	if ids := utils.Single(req.GroupIDs, utils.Slice(groups, func(group *relationTb.GroupModel) string {
 		return group.GroupID
 	})); len(ids) > 0 {
-		return nil, constant.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ","))
+		return nil, errs.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ","))
 	}
 	groupUserMap, err := s.GroupDatabase.MapGroupMemberUserID(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
 	}
 	if ids := utils.Single(req.GroupIDs, utils.Keys(groupUserMap)); len(ids) > 0 {
-		return nil, constant.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ",")))
+		return nil, errs.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ",")))
 	}
 	resp.GroupAbstractInfos = utils.Slice(groups, func(group *relationTb.GroupModel) *pbGroup.GroupAbstractInfo {
 		users := groupUserMap[group.GroupID]
@@ -1094,7 +1095,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.GetUserInGroupMembersReq) (*pbGroup.GetUserInGroupMembersResp, error) {
 	resp := &pbGroup.GetUserInGroupMembersResp{}
 	if len(req.GroupIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("groupIDs empty")
+		return nil, errs.ErrArgs.Wrap("groupIDs empty")
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.UserID}, req.GroupIDs, nil)
 	if err != nil {
@@ -1127,7 +1128,7 @@ func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbGroup.Ge
 func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
 	resp := &pbGroup.GetGroupMemberRoleLevelResp{}
 	if len(req.RoleLevels) == 0 {
-		return nil, constant.ErrArgs.Wrap("RoleLevels empty")
+		return nil, errs.ErrArgs.Wrap("RoleLevels empty")
 	}
 	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels)
 	if err != nil {

internal/rpc/group/super_group.go

@@ -4,6 +4,7 @@ import (
 	"OpenIM/pkg/common/constant"
 	"OpenIM/pkg/common/db/table/relation"
 	"OpenIM/pkg/common/db/table/unrelation"
+	"OpenIM/pkg/errs"
 	pbGroup "OpenIM/pkg/proto/group"
 	sdkws "OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
@@ -29,7 +30,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
 		return e.GroupID
 	})
 	if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
-		return nil, constant.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
+		return nil, errs.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
 	}
 	groups, err := s.GroupDatabase.FindGroup(ctx, joinSuperGroup.GroupIDs)
 	if err != nil {
@@ -39,7 +40,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
 		return e.GroupID
 	})
 	if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(groupMap)); len(ids) > 0 {
-		return nil, constant.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
+		return nil, errs.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
 	}
 	superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, joinSuperGroup.GroupIDs)
 	if err != nil {
@@ -57,7 +58,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
 func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
 	resp = &pbGroup.GetSuperGroupsInfoResp{}
 	if len(req.GroupIDs) == 0 {
-		return nil, constant.ErrArgs.Wrap("groupIDs empty")
+		return nil, errs.ErrArgs.Wrap("groupIDs empty")
 	}
 	groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
 	if err != nil {

internal/rpc/msg/send_msg.go

@@ -3,6 +3,7 @@ package msg
 import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/constant"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/msg"
 	"OpenIM/pkg/proto/sdkws"
 	"OpenIM/pkg/utils"
@@ -80,7 +81,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			return nil, err
 		}
 		if black {
-			return nil, constant.ErrBlockedByPeer.Wrap()
+			return nil, errs.ErrBlockedByPeer.Wrap()
 		}
 		if *config.Config.MessageVerify.FriendVerify {
 			friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID)
@@ -88,7 +89,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 				return nil, err
 			}
 			if !friend {
-				return nil, constant.ErrNotPeersFriend.Wrap()
+				return nil, errs.ErrNotPeersFriend.Wrap()
 			}
 			return nil, nil
 		}
@@ -108,14 +109,14 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			return userIDList, nil
 		}
 		if !utils.IsContain(data.MsgData.SendID, userIDList) {
-			return nil, constant.ErrNotInGroupYet.Wrap()
+			return nil, errs.ErrNotInGroupYet.Wrap()
 		}
 		isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
 		if err != nil {
 			return nil, err
 		}
 		if isMute {
-			return nil, constant.ErrMutedInGroup.Wrap()
+			return nil, errs.ErrMutedInGroup.Wrap()
 		}
 
 		isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -127,7 +128,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 		}
 
 		if isMute {
-			return nil, constant.ErrMutedGroup.Wrap()
+			return nil, errs.ErrMutedGroup.Wrap()
 		}
 		return userIDList, nil
 	case constant.SuperGroupChatType:
@@ -139,7 +140,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			revokeMessage := new(MessageRevoked)
 			err := utils.JsonStringToStruct(string(data.MsgData.Content), revokeMessage)
 			if err != nil {
-				return nil, constant.ErrArgs.Wrap()
+				return nil, errs.ErrArgs.Wrap()
 			}
 
 			if revokeMessage.RevokerID != revokeMessage.SourceMessageSendID {
@@ -153,7 +154,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 					revokeMessage.SourceMessageSendID = resp[0].SendID
 					data.MsgData.Content = []byte(utils.StructToJsonString(revokeMessage))
 				} else {
-					return nil, constant.ErrData.Wrap("MsgData")
+					return nil, errs.ErrData.Wrap("MsgData")
 				}
 			}
 		}
@@ -172,7 +173,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			return userIDList, nil
 		} else {
 			if !utils.IsContain(data.MsgData.SendID, userIDList) {
-				return nil, constant.ErrNotInGroupYet.Wrap()
+				return nil, errs.ErrNotInGroupYet.Wrap()
 			}
 		}
 		isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -180,7 +181,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			return nil, err
 		}
 		if isMute {
-			return nil, constant.ErrMutedInGroup.Wrap()
+			return nil, errs.ErrMutedInGroup.Wrap()
 		}
 
 		isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -191,7 +192,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
 			return userIDList, nil
 		}
 		if isMute {
-			return nil, constant.ErrMutedGroup.Wrap()
+			return nil, errs.ErrMutedGroup.Wrap()
 		}
 		return userIDList, nil
 
@@ -328,7 +329,7 @@ func (m *msgServer) sendMsgToGroupOptimization(ctx context.Context, list []strin
 		}
 		if isSend {
 			if v == "" || groupPB.MsgData.SendID == "" {
-				return constant.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty")
+				return errs.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty")
 			}
 			err := m.MsgDatabase.MsgToMQ(ctx, v, &msgToMQGroup)
 			if err != nil {

internal/rpc/msg/send_pull.go

@@ -3,6 +3,7 @@ package msg
 import (
 	"OpenIM/pkg/common/constant"
 	promePkg "OpenIM/pkg/common/prome"
+	"OpenIM/pkg/errs"
 	pbConversation "OpenIM/pkg/proto/conversation"
 	"OpenIM/pkg/proto/msg"
 	"OpenIM/pkg/proto/sdkws"
@@ -16,7 +17,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
 	resp = &msg.SendMsgResp{}
 	promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
 	// callback
-	if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 
@@ -30,7 +31,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
 		return nil, err
 	}
 	// callback
-	if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 
@@ -62,7 +63,7 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq
 
 func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
 	promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
-	if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 	_, err = m.messageVerification(ctx, req)
@@ -77,17 +78,17 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq)
 	if isSend {
 		err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle)
 		if err != nil {
-			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+			return nil, errs.ErrInternalServer.Wrap("insert to mq")
 		}
 	}
 	if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
 		err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle)
 		if err != nil {
-			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+			return nil, errs.ErrInternalServer.Wrap("insert to mq")
 		}
 	}
 	err = CallbackAfterSendSingleMsg(ctx, req)
-	if err != nil && err != constant.ErrCallbackContinue {
+	if err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 	promePkg.Inc(promePkg.SingleChatMsgProcessSuccessCounter)
@@ -103,7 +104,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
 	// callback
 	promePkg.Inc(promePkg.GroupChatMsgRecvSuccessCounter)
 	err = CallbackBeforeSendGroupMsg(ctx, req)
-	if err != nil && err != constant.ErrCallbackContinue {
+	if err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 
@@ -168,7 +169,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
 
 	// callback
 	err = CallbackAfterSendGroupMsg(ctx, req)
-	if err != nil && err != constant.ErrCallbackContinue {
+	if err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 
@@ -235,10 +236,10 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
 	resp = &msg.SendMsgResp{}
 	flag := isMessageHasReadEnabled(req.MsgData)
 	if !flag {
-		return nil, constant.ErrMessageHasReadDisable.Wrap()
+		return nil, errs.ErrMessageHasReadDisable.Wrap()
 	}
 	m.encapsulateMsgData(req.MsgData)
-	if err := CallbackMsgModify(ctx, req); err != nil && err != constant.ErrCallbackContinue {
+	if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
 		return nil, err
 	}
 	switch req.MsgData.SessionType {
@@ -251,7 +252,7 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
 	case constant.SuperGroupChatType:
 		return m.sendMsgSuperGroupChat(ctx, req)
 	default:
-		return nil, constant.ErrArgs.Wrap("unknown sessionType")
+		return nil, errs.ErrArgs.Wrap("unknown sessionType")
 	}
 }
 

internal/rpc/user/user.go

@@ -12,6 +12,7 @@ import (
 	"OpenIM/pkg/common/tokenverify"
 	"OpenIM/pkg/common/tracelog"
 	registry "OpenIM/pkg/discoveryregistry"
+	"OpenIM/pkg/errs"
 	"OpenIM/pkg/proto/sdkws"
 	pbuser "OpenIM/pkg/proto/user"
 	"OpenIM/pkg/utils"
@@ -38,7 +39,7 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	}
 	users := make([]*tablerelation.UserModel, 0)
 	if len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname) {
-		return constant.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
+		return errs.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
 	}
 	for k, v := range config.Config.Manager.AppManagerUid {
 		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k]})
@@ -114,7 +115,7 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
 func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) {
 	resp = &pbuser.AccountCheckResp{}
 	if utils.Duplicate(req.CheckUserIDs) {
-		return nil, constant.ErrArgs.Wrap("userID repeated")
+		return nil, errs.ErrArgs.Wrap("userID repeated")
 	}
 	err = tokenverify.CheckAdmin(ctx)
 	if err != nil {
@@ -156,7 +157,7 @@ func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPagi
 func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) {
 	resp = &pbuser.UserRegisterResp{}
 	if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) {
-		return nil, constant.ErrArgs.Wrap("userID repeated")
+		return nil, errs.ErrArgs.Wrap("userID repeated")
 	}
 	userIDs := make([]string, 0)
 	for _, v := range req.Users {
@@ -167,7 +168,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 		return nil, err
 	}
 	if exist {
-		return nil, constant.ErrRegisteredAlready.Wrap("userID registered already")
+		return nil, errs.ErrRegisteredAlready.Wrap("userID registered already")
 	}
 	users, err := (*convert.PBUser)(nil).PB2DB(req.Users)
 	if err != nil {

internal/startrpc/start.go

@@ -5,7 +5,7 @@ import (
 	"OpenIM/pkg/common/config"
 	"OpenIM/pkg/common/constant"
 	"OpenIM/pkg/common/log"
-	"OpenIM/pkg/common/middleware"
+	"OpenIM/pkg/common/mw"
 	"OpenIM/pkg/common/prome"
 	"OpenIM/pkg/discoveryregistry"
 	"flag"
@@ -36,7 +36,7 @@ func start(rpcPort int, rpcRegisterName string, prometheusPorts int, rpcFn func(
 	if err != nil {
 		return err
 	}
-	options = append(options, grpc.UnaryInterceptor(middleware.RpcServerInterceptor)) // ctx 中间件
+	options = append(options, mw.GrpcServer()) // ctx 中间件
 	if config.Config.Prometheus.Enable {
 		prome.NewGrpcRequestCounter()
 		prome.NewGrpcRequestFailedCounter()