From 1fc7c4434c714550358da8badd12f2395fc30fbd Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 14:29:37 +0800 Subject: [PATCH 1/7] group --- cmd/open_im_api/main.go | 2 + internal/rpc/fault_tolerant/conn.go | 3 +- internal/rpc/group/group.go | 49 ++---------------- pkg/common/middleware/gin.go | 42 ++++++++++++++++ pkg/common/middleware/rpc.go | 78 +++++++++++++++++++++++++++++ 5 files changed, 128 insertions(+), 46 deletions(-) create mode 100644 pkg/common/middleware/gin.go create mode 100644 pkg/common/middleware/rpc.go diff --git a/cmd/open_im_api/main.go b/cmd/open_im_api/main.go index 1dc3ab6fb..97311f1cc 100644 --- a/cmd/open_im_api/main.go +++ b/cmd/open_im_api/main.go @@ -15,6 +15,7 @@ import ( "Open_IM/internal/api/user" "Open_IM/pkg/common/config" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/middleware" "Open_IM/pkg/utils" "flag" "fmt" @@ -49,6 +50,7 @@ func main() { r := gin.New() r.Use(gin.Recovery()) r.Use(utils.CorsHandler()) + r.Use(middleware.GinParseOperationID) log.Info("load config: ", config.Config) r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler)) if config.Config.Prometheus.Enable { diff --git a/internal/rpc/fault_tolerant/conn.go b/internal/rpc/fault_tolerant/conn.go index 0d911346c..5ba212400 100644 --- a/internal/rpc/fault_tolerant/conn.go +++ b/internal/rpc/fault_tolerant/conn.go @@ -3,6 +3,7 @@ package fault_tolerant import ( "Open_IM/pkg/common/config" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/middleware" "Open_IM/pkg/utils" "github.com/OpenIMSDK/getcdv3" "google.golang.org/grpc" @@ -75,7 +76,7 @@ func GetConfigConn(serviceName string, operationID string) *grpc.ClientConn { } target := rpcRegisterIP + ":" + utils.Int32ToString(int32(configPortList[0])) log.Info(operationID, "rpcRegisterIP ", rpcRegisterIP, " port ", configPortList, " grpc target: ", target, " serviceName: ", serviceName) - conn, err := grpc.Dial(target, grpc.WithInsecure()) + conn, err := grpc.Dial(target, grpc.WithInsecure(), grpc.WithUnaryInterceptor(middleware.RpcClientInterceptor)) if err != nil { log.Error(operationID, "grpc.Dail failed ", err.Error()) return nil diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 8f025888b..c5c19c198 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -9,25 +9,20 @@ import ( imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" rocksCache "Open_IM/pkg/common/db/rocks_cache" "Open_IM/pkg/common/log" + "Open_IM/pkg/common/middleware" promePkg "Open_IM/pkg/common/prometheus" "Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/trace_log" cp "Open_IM/pkg/common/utils" - open_im_sdk "Open_IM/pkg/proto/sdk_ws" - "github.com/OpenIMSDK/getcdv3" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/metadata" - "google.golang.org/grpc/status" - "path" - "runtime/debug" - pbCache "Open_IM/pkg/proto/cache" pbConversation "Open_IM/pkg/proto/conversation" pbGroup "Open_IM/pkg/proto/group" + open_im_sdk "Open_IM/pkg/proto/sdk_ws" pbUser "Open_IM/pkg/proto/user" "Open_IM/pkg/utils" "context" "errors" + "github.com/OpenIMSDK/getcdv3" "math/big" "net" "strconv" @@ -58,42 +53,6 @@ func NewGroupServer(port int) *groupServer { } } -func UnaryServerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { - defer func() { - if r := recover(); r != nil { - log.NewError("", info.FullMethod, "panic", r, "stack", string(debug.Stack())) - } - }() - funcName := path.Base(info.FullMethod) - md, ok := metadata.FromIncomingContext(ctx) - if !ok { - return nil, errors.New("not metadata") - } - operationID := md.Get("operationID")[0] - opUserID := md.Get("opUserID")[0] - ctx = trace_log.NewRpcCtx(ctx, funcName, operationID) - defer trace_log.ShowLog(ctx) - _ = opUserID - trace_log.SetContextInfo(ctx, funcName, err, "rpc req", req.(interface{ String() string }).String()) - resp, err = handler(ctx, req) - if err != nil { - errInfo := constant.ToAPIErrWithErr(err) - var code codes.Code - if errInfo.ErrCode == 0 { - code = codes.Unknown - } else { - code = codes.Code(errInfo.ErrCode) - } - sta, err := status.New(code, errInfo.ErrMsg).WithDetails(wrapperspb.String(errInfo.DetailErrMsg)) - if err != nil { - return nil, err - } - return nil, sta.Err() - } - trace_log.SetContextInfo(ctx, funcName, err, "rpc resp", resp.(interface{ String() string }).String()) - return -} - func (s *groupServer) Run() { log.NewInfo("", "group rpc start ") listenIP := "" @@ -116,7 +75,7 @@ func (s *groupServer) Run() { var grpcOpts = []grpc.ServerOption{ grpc.MaxRecvMsgSize(recvSize), grpc.MaxSendMsgSize(sendSize), - grpc.UnaryInterceptor(UnaryServerInterceptor), + grpc.UnaryInterceptor(middleware.RpcServerInterceptor), } if config.Config.Prometheus.Enable { promePkg.NewGrpcRequestCounter() diff --git a/pkg/common/middleware/gin.go b/pkg/common/middleware/gin.go new file mode 100644 index 000000000..c25b0c3fc --- /dev/null +++ b/pkg/common/middleware/gin.go @@ -0,0 +1,42 @@ +package middleware + +import ( + "bytes" + "encoding/json" + "github.com/gin-gonic/gin" + "io/ioutil" + "net/http" +) + +func GinParseOperationID(c *gin.Context) { + if c.Request.Method == http.MethodPost { + operationID := c.Request.Header.Get("operationID") + if operationID == "" { + body, err := ioutil.ReadAll(c.Request.Body) + if err != nil { + c.String(400, "read request body error: "+err.Error()) + c.Abort() + return + } + req := struct { + OperationID string `json:"operationID"` + }{} + if err := json.Unmarshal(body, &req); err != nil { + c.String(400, "get operationID error: "+err.Error()) + c.Abort() + return + } + if req.OperationID == "" { + c.String(400, "operationID empty") + c.Abort() + return + } + c.Request.Body = ioutil.NopCloser(bytes.NewReader(body)) + operationID = req.OperationID + } + c.Set("operationID", operationID) + c.Next() + return + } + c.Next() +} diff --git a/pkg/common/middleware/rpc.go b/pkg/common/middleware/rpc.go new file mode 100644 index 000000000..c1282bbb4 --- /dev/null +++ b/pkg/common/middleware/rpc.go @@ -0,0 +1,78 @@ +package middleware + +import ( + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/log" + "Open_IM/pkg/common/trace_log" + "Open_IM/pkg/utils" + "context" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/wrapperspb" + "path" + "runtime/debug" +) + +func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) { + defer func() { + if r := recover(); r != nil { + log.NewError("", info.FullMethod, "panic", r, "stack", string(debug.Stack())) + } + }() + funcName := path.Base(info.FullMethod) + md, ok := metadata.FromIncomingContext(ctx) + if !ok { + return nil, status.New(codes.InvalidArgument, "missing metadata").Err() + } + var operationID string + if opts := md.Get("operationID"); len(opts) != 1 || opts[0] == "" { + return nil, status.New(codes.InvalidArgument, "operationID error").Err() + } else { + operationID = opts[0] + } + var opUserID string + if opts := md.Get("opUserID"); len(opts) != 1 { + return nil, status.New(codes.InvalidArgument, "opUserID error").Err() + } else { + opUserID = opts[0] + } + ctx = trace_log.NewRpcCtx(ctx, funcName, operationID) + defer trace_log.ShowLog(ctx) + trace_log.SetContextInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", req.(interface{ String() string }).String()) + resp, err = handler(ctx, req) + if err != nil { + trace_log.SetContextInfo(ctx, funcName, err) + errInfo := constant.ToAPIErrWithErr(err) + var code codes.Code + if errInfo.ErrCode == 0 { + code = codes.Unknown + } else { + code = codes.Code(errInfo.ErrCode) + } + sta, err := status.New(code, errInfo.ErrMsg).WithDetails(wrapperspb.String(errInfo.DetailErrMsg)) + if err != nil { + return nil, err + } + return nil, sta.Err() + } + trace_log.SetContextInfo(ctx, funcName, nil, "rpcResp", resp.(interface{ String() string }).String()) + return +} + +func RpcClientInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) { + if cc == nil { + return utils.Wrap(constant.ErrRpcConn, "") + } + operationID, ok := ctx.Value("operationID").(string) + if !ok { + return utils.Wrap(constant.ErrArgs, "ctx missing operationID") + } + opUserID, ok := ctx.Value("opUserID").(string) + if !ok { + return utils.Wrap(constant.ErrArgs, "ctx missing opUserID") + } + md := metadata.Pairs("operationID", operationID, "opUserID", opUserID) + return invoker(metadata.NewOutgoingContext(ctx, md), method, req, reply, cc, opts...) +} From b05e4f131ac1572dcbd744750b70af1cc6cd34a2 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 14:51:24 +0800 Subject: [PATCH 2/7] group rpc --- internal/rpc/group/group.go | 652 +++++++++++------------------------- 1 file changed, 189 insertions(+), 463 deletions(-) diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index c5c19c198..52e236655 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -222,145 +222,15 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR return resp, nil } -func (s *groupServer) CreateGroup1(ctx context.Context, req *pbGroup.CreateGroupReq) (resp *pbGroup.CreateGroupResp, _ error) { - resp = &pbGroup.CreateGroupResp{CommonResp: &open_im_sdk.CommonResp{}, GroupInfo: &open_im_sdk.GroupInfo{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() - if err := token_verify.CheckAccessV2(ctx, req.OpUserID, req.OwnerUserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - var groupOwnerNum int - var userIDs []string - for _, info := range req.InitMemberList { - if info.RoleLevel == constant.GroupOwner { - groupOwnerNum++ - } - userIDs = append(userIDs, info.UserID) - } - if req.OwnerUserID != "" { - groupOwnerNum++ - userIDs = append(userIDs, req.OwnerUserID) - } - if groupOwnerNum != 1 { - constant.SetErrorForResp(constant.ErrArgs, resp.CommonResp) - return - } - if utils.IsRepeatStringSlice(userIDs) { - constant.SetErrorForResp(constant.ErrArgs, resp.CommonResp) - return - } - users, err := rocksCache.GetUserInfoFromCacheBatch(ctx, userIDs) - if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - if len(users) != len(userIDs) { - constant.SetErrorForResp(constant.ErrArgs, resp.CommonResp) - return - } - userMap := make(map[string]*imdb.User) - for i, user := range users { - userMap[user.UserID] = users[i] - } - if err := s.DelGroupAndUserCache(ctx, "", userIDs); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - if err := callbackBeforeCreateGroup(ctx, req); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - groupId := req.GroupInfo.GroupID - if groupId == "" { - groupId = utils.Md5(req.OperationID + strconv.FormatInt(time.Now().UnixNano(), 10)) - bi := big.NewInt(0) - bi.SetString(groupId[0:8], 16) - groupId = bi.String() - } - groupInfo := imdb.Group{} - utils.CopyStructFields(&groupInfo, req.GroupInfo) - groupInfo.CreatorUserID = req.OpUserID - groupInfo.GroupID = groupId - groupInfo.CreateTime = time.Now() - if groupInfo.NotificationUpdateTime.Unix() < 0 { - groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0) - } - if req.GroupInfo.GroupType != constant.SuperGroup { - var groupMembers []*imdb.GroupMember - joinGroup := func(userID string, roleLevel int32) error { - groupMember := &imdb.GroupMember{GroupID: groupId, RoleLevel: roleLevel, OperatorUserID: req.OpUserID, JoinSource: constant.JoinByInvitation, InviterUserID: req.OpUserID} - user := userMap[userID] - utils.CopyStructFields(&groupMember, user) - if err := CallbackBeforeMemberJoinGroup(ctx, req.OperationID, groupMember, groupInfo.Ex); err != nil { - return err - } - groupMembers = append(groupMembers, groupMember) - return nil - } - if req.OwnerUserID == "" { - if err := joinGroup(req.OwnerUserID, constant.GroupOwner); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - } - for _, info := range req.InitMemberList { - if err := joinGroup(info.UserID, info.RoleLevel); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - } - if err := (*imdb.GroupMember)(nil).Create(ctx, groupMembers); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - } else { - if err := db.DB.CreateSuperGroup(groupId, userIDs, len(userIDs)); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - } - if err := (*imdb.Group)(nil).Create(ctx, []*imdb.Group{&groupInfo}); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return - } - utils.CopyStructFields(resp.GroupInfo, groupInfo) - resp.GroupInfo.MemberCount = uint32(len(userIDs)) - if req.GroupInfo.GroupType != constant.SuperGroup { - chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, userIDs) - } else { - for _, userID := range userIDs { - if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { - trace_log.SetContextInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) - } - } - go func() { - for _, v := range userIDs { - chat.SuperGroupNotification(req.OperationID, v, v) - } - }() - } - return -} +func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJoinedGroupListReq) (*pbGroup.GetJoinedGroupListResp, error) { + resp := &pbGroup.GetJoinedGroupListResp{CommonResp: &open_im_sdk.CommonResp{}} -func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJoinedGroupListReq) (resp *pbGroup.GetJoinedGroupListResp, _ error) { - resp = &pbGroup.GetJoinedGroupListResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() if err := token_verify.CheckAccessV2(ctx, req.OpUserID, req.FromUserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } joinedGroupList, err := rocksCache.GetJoinedGroupIDListFromCache(ctx, req.FromUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } for _, groupID := range joinedGroupList { var groupNode open_im_sdk.GroupInfo @@ -397,28 +267,22 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo groupNode.OwnerUserID = owner.UserID resp.GroupList = append(resp.GroupList, &groupNode) } - return + return resp, nil } -func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (resp *pbGroup.InviteUserToGroupResp, _ error) { - resp = &pbGroup.InviteUserToGroupResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) { + resp := &pbGroup.InviteUserToGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) { constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrIdentity, "") } groupInfo, err := (*imdb.Group)(nil).Take(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.Status == constant.GroupStatusDismissed { - constant.SetErrorForResp(constant.ErrDismissedAlready, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrDismissedAlready, "") } if groupInfo.NeedVerification == constant.AllNeedVerification && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) { @@ -448,11 +312,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite chat.JoinGroupApplicationNotification(&joinReq) } } - return + return resp, nil } if err := s.DelGroupAndUserCache(ctx, req.GroupID, req.InvitedUserIDList); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } //from User: invite: applicant //to user: invite: invited @@ -484,8 +347,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite toInsertInfo.InviterUserID = req.OpUserID toInsertInfo.JoinSource = constant.JoinByInvitation if err := CallbackBeforeMemberJoinGroup(ctx, req.OperationID, &toInsertInfo, groupInfo.Ex); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.InsertIntoGroupMember(toInsertInfo) if err != nil { @@ -504,8 +366,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite } else { okUserIDList = req.InvitedUserIDList if err := db.DB.AddUserToSuperGroup(req.GroupID, req.InvitedUserIDList); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } @@ -521,26 +382,20 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite chat.SuperGroupNotification(req.OperationID, v, v) } } - return + return resp, nil } -func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (resp *pbGroup.GetGroupAllMemberResp, err error) { - resp = &pbGroup.GetGroupAllMemberResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) { + resp := &pbGroup.GetGroupAllMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.GroupType != constant.SuperGroup { memberList, err := rocksCache.GetGroupMembersInfoFromCache(ctx, req.Count, req.Offset, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } for _, v := range memberList { var node open_im_sdk.GroupMemberFullInfo @@ -548,20 +403,15 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro resp.MemberList = append(resp.MemberList, &node) } } - return + return resp, nil } -func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (resp *pbGroup.GetGroupMemberListResp, err error) { - resp = &pbGroup.GetGroupMemberListResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) { + resp := &pbGroup.GetGroupMemberListResp{CommonResp: &open_im_sdk.CommonResp{}} + memberList, err := imdb.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } for _, v := range memberList { @@ -575,7 +425,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr } else { resp.NextSeq = req.NextSeq + int32(len(memberList)) } - return + return resp, nil } func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) { @@ -598,17 +448,12 @@ func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) { return opFlag, nil } -func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (resp *pbGroup.KickGroupMemberResp, _ error) { - resp = &pbGroup.KickGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) { + resp := &pbGroup.KickGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } var okUserIDList []string if groupInfo.GroupType != constant.SuperGroup { @@ -617,11 +462,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou opInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, req.OpUserID) if err != nil { constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if opInfo.RoleLevel == constant.GroupOrdinaryUsers { - constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrNoPermission, "") } else if opInfo.RoleLevel == constant.GroupOwner { opFlag = 2 //owner } else { @@ -635,12 +479,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou if len(req.KickedUserIDList) == 0 { //log.NewError(req.OperationID, "failed, kick list 0") //return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}, nil - constant.SetErrorForResp(constant.ErrArgs, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrArgs, "") } if err := s.DelGroupAndUserCache(ctx, req.GroupID, req.KickedUserIDList); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } //remove for _, v := range req.KickedUserIDList { @@ -684,8 +526,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou reqPb.Conversation = &c etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } client := pbUser.NewUserClient(etcdConn) respPb, err := client.SetConversation(context.Background(), &reqPb) @@ -694,8 +535,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou } else { okUserIDList = req.KickedUserIDList if err := db.DB.RemoverUserFromSuperGroup(req.GroupID, okUserIDList); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } @@ -719,22 +559,16 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou }() } - return + return resp, nil } -func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (resp *pbGroup.GetGroupMembersInfoResp, err error) { - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "rpc req", req.String(), "rpc resp", resp.String()) - trace_log.ShowLog(ctx) - }() - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - resp = &pbGroup.GetGroupMembersInfoResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) { + resp := &pbGroup.GetGroupMembersInfoResp{CommonResp: &open_im_sdk.CommonResp{}} resp.MemberList = []*open_im_sdk.GroupMemberFullInfo{} for _, userID := range req.MemberList { groupMember, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, userID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } var memberNode open_im_sdk.GroupMemberFullInfo utils.CopyStructFields(&memberNode, groupMember) @@ -767,16 +601,11 @@ func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sd return nil } -func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (resp *pbGroup.GetGroupApplicationListResp, err error) { - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - - resp = &pbGroup.GetGroupApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) { + resp := &pbGroup.GetGroupApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} reply, err := imdb.GetRecvGroupApplicationList(req.FromUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return resp, nil + return nil, err } var errResult error trace_log.SetContextInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply) @@ -799,20 +628,14 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup. resp.GroupRequestList = append(resp.GroupRequestList, &node) } if errResult != nil && len(resp.GroupRequestList) == 0 { - constant.SetErrorForResp(err, resp.CommonResp) - return resp, nil + return nil, err } trace_log.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String()) return resp, nil } -func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (resp *pbGroup.GetGroupsInfoResp, _ error) { - resp = &pbGroup.GetGroupsInfoResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) { + resp := &pbGroup.GetGroupsInfoResp{CommonResp: &open_im_sdk.CommonResp{}} groupsInfoList := make([]*open_im_sdk.GroupInfo, 0) for _, groupID := range req.GroupIDList { groupInfoFromRedis, err := rocksCache.GetGroupInfoFromCache(ctx, groupID) @@ -826,7 +649,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI groupsInfoList = append(groupsInfoList, &groupInfo) } resp.GroupInfoList = groupsInfoList - return + return resp, nil } func CheckPermission(ctx context.Context, groupID string, userID string) (err error) { @@ -839,16 +662,15 @@ func CheckPermission(ctx context.Context, groupID string, userID string) (err er return nil } -func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (resp *pbGroup.GroupApplicationResponseResp, _ error) { - resp = &pbGroup.GroupApplicationResponseResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) { + resp := &pbGroup.GroupApplicationResponseResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if err := CheckPermission(ctx, req.GroupID, req.OpUserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupRequest := imdb.GroupRequest{} utils.CopyStructFields(&groupRequest, req) @@ -856,24 +678,20 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup groupRequest.HandleUserID = req.OpUserID groupRequest.HandledTime = time.Now() if err := (&imdb.GroupRequest{}).Update(ctx, []*imdb.GroupRequest{&groupRequest}); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if req.HandleResult == constant.GroupResponseAgree { user, err := imdb.GetUserByUserID(req.FromUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } request, err := (&imdb.GroupRequest{}).Take(ctx, req.GroupID, req.FromUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } member := imdb.GroupMember{} member.GroupID = req.GroupID @@ -887,29 +705,27 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0) err = CallbackBeforeMemberJoinGroup(ctx, req.OperationID, &member, groupInfo.Ex) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{&member}) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } etcdCacheConn, err := fault_tolerant.GetDefaultConn(config.Config.RpcRegisterName.OpenImCacheName, req.OperationID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } cacheClient := pbCache.NewCacheClient(etcdCacheConn) cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{OperationID: req.OperationID, GroupID: req.GroupID}) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if cacheResp.CommonResp.ErrCode != 0 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, utils.Wrap(&constant.ErrInfo{ + ErrCode: cacheResp.CommonResp.ErrCode, + ErrMsg: cacheResp.CommonResp.ErrMsg, + }, "") } _ = rocksCache.DelGroupMemberListHashFromCache(ctx, req.GroupID) _ = rocksCache.DelJoinedGroupIDListFromCache(ctx, req.FromUserID) @@ -919,55 +735,48 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup } else if req.HandleResult == constant.GroupResponseRefuse { chat.GroupApplicationRejectedNotification(req) } else { - constant.SetErrorForResp(constant.ErrArgs, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrArgs, "") } - return + return resp, nil } -func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (resp *pbGroup.JoinGroupResp, _ error) { - resp = &pbGroup.JoinGroupResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) { + resp := &pbGroup.JoinGroupResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if _, err := imdb.GetUserByUserID(req.OpUserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.Status == constant.GroupStatusDismissed { constant.SetErrorForResp(constant.ErrDismissedAlready, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrDismissedAlready, "") } if groupInfo.NeedVerification == constant.Directly { if groupInfo.GroupType != constant.SuperGroup { us, err := imdb.GetUserByUserID(req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } //to group member groupMember := imdb.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: req.OpUserID} utils.CopyStructFields(&groupMember, us) if err := CallbackBeforeMemberJoinGroup(ctx, req.OperationID, &groupMember, groupInfo.Ex); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{req.OpUserID}); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.InsertIntoGroupMember(groupMember) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } var sessionType int @@ -988,18 +797,16 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) reqPb.Conversation = &c etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } client := pbUser.NewUserClient(etcdConn) respPb, err := client.SetConversation(context.Background(), &reqPb) trace_log.SetContextInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb) chat.MemberEnterDirectlyNotification(req.GroupID, req.OpUserID, req.OperationID) - return + return resp, nil } else { constant.SetErrorForResp(constant.ErrGroupTypeNotSupport, resp.CommonResp) - log.Error(req.OperationID, "JoinGroup rpc failed, group type: ", groupInfo.GroupType, "not support directly") - return + return resp, nil } } var groupRequest imdb.GroupRequest @@ -1009,15 +816,14 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) groupRequest.JoinSource = req.JoinSource err = imdb.InsertIntoGroupRequest(groupRequest) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.JoinGroupApplicationNotification(req) - return + return resp, nil } -func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (resp *pbGroup.QuitGroupResp, _ error) { - resp = &pbGroup.QuitGroupResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) { + resp := &pbGroup.QuitGroupResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1025,29 +831,24 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) }() groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.GroupType != constant.SuperGroup { _, err = rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{req.OpUserID}); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, req.OpUserID) if err != nil { - log.Error(req.OperationID, "JoinGroup rpc failed, group type: ", groupInfo.GroupType, "not support directly") - return + return nil, err } } else { okUserIDList := []string{req.OpUserID} if err := db.DB.RemoverUserFromSuperGroup(req.GroupID, okUserIDList); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } @@ -1059,7 +860,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) _ = rocksCache.DelGroupMemberListHashFromCache(ctx, req.GroupID) chat.SuperGroupNotification(req.OperationID, req.OpUserID, req.OpUserID) } - return + return resp, nil } func hasAccess(req *pbGroup.SetGroupInfoReq) bool { @@ -1070,7 +871,6 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool { if err != nil { log.NewError(req.OperationID, "GetGroupMemberInfoByGroupIDAndUserID failed, ", err.Error(), req.GroupInfoForSet.GroupID, req.OpUserID) return false - } if groupUserInfo.RoleLevel == constant.GroupOwner || groupUserInfo.RoleLevel == constant.GroupAdmin { return true @@ -1078,25 +878,22 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool { return false } -func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (resp *pbGroup.SetGroupInfoResp, err error) { - resp = &pbGroup.SetGroupInfoResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) { + resp := &pbGroup.SetGroupInfoResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if !hasAccess(req) { - constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrIdentity, "") } group, err := imdb.GetGroupInfoByGroupID(req.GroupInfoForSet.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if group.Status == constant.GroupStatusDismissed { - constant.SetErrorForResp(constant.ErrDismissedAlready, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrDismissedAlready, "") } var changedType int32 @@ -1126,8 +923,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf m := make(map[string]interface{}) m["need_verification"] = req.GroupInfoForSet.NeedVerification.Value if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } if req.GroupInfoForSet.LookMemberInfo != nil { @@ -1135,8 +931,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf m := make(map[string]interface{}) m["look_member_info"] = req.GroupInfoForSet.LookMemberInfo.Value if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } if req.GroupInfoForSet.ApplyMemberFriend != nil { @@ -1144,8 +939,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf m := make(map[string]interface{}) m["apply_member_friend"] = req.GroupInfoForSet.ApplyMemberFriend.Value if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { - constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) - return + return nil, err } } //only administrators can set group information @@ -1156,13 +950,11 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf groupInfo.NotificationUpdateTime = time.Now() } if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupInfoForSet.GroupID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.SetGroupInfo(groupInfo) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if changedType != 0 { chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification) @@ -1172,18 +964,15 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: req.OperationID, GroupID: req.GroupInfoForSet.GroupID} etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } client := pbCache.NewCacheClient(etcdConn) cacheResp, err := client.GetGroupMemberIDListFromCache(ctx, getGroupMemberIDListFromCacheReq) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err = constant.CommonResp2Err(cacheResp.CommonResp); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } var conversationReq pbConversation.ModifyConversationFieldReq conversation := pbConversation.Conversation{ @@ -1199,18 +988,17 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf conversationReq.UserIDList = cacheResp.UserIDList nEtcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } nClient := pbConversation.NewConversationClient(nEtcdConn) conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq) trace_log.SetContextInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) } - return + return resp, nil } -func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (resp *pbGroup.TransferGroupOwnerResp, _ error) { - resp = &pbGroup.TransferGroupOwnerResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) { + resp := &pbGroup.TransferGroupOwnerResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1219,47 +1007,40 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.Status == constant.GroupStatusDismissed { - constant.SetErrorForResp(constant.ErrDismissedAlready, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrDismissedAlready, "") } if req.OldOwnerUserID == req.NewOwnerUserID { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.NewOwnerUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.OldOwnerUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers} err = imdb.UpdateGroupMemberInfo(groupMemberInfo) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMemberInfo = imdb.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner} err = imdb.UpdateGroupMemberInfo(groupMemberInfo) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupOwnerTransferredNotification(req) - return + return resp, nil } -func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) (resp *pbGroup.GetGroupsResp, err error) { - resp = &pbGroup.GetGroupsResp{ +func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) { + resp := &pbGroup.GetGroupsResp{ CommonResp: &open_im_sdk.CommonResp{}, Groups: []*pbGroup.CMSGroup{}, Pagination: &open_im_sdk.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}, @@ -1275,21 +1056,18 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) if errors.Is(err, gorm.ErrRecordNotFound) { return resp, nil } - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } resp.GroupNum = 1 groupInfo := &open_im_sdk.GroupInfo{} utils.CopyStructFields(groupInfo, groupInfoDB) groupMember, err := imdb.GetGroupOwnerInfoByGroupID(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } memberNum, err := imdb.GetGroupMembersCount(req.GroupID, "") if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupInfo.MemberCount = uint32(memberNum) groupInfo.CreateTime = uint32(groupInfoDB.CreateTime.Unix()) @@ -1314,25 +1092,18 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) } resp.GroupNum = int32(count) } - return + return resp, nil } -func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (resp *pbGroup.GetGroupMembersCMSResp, _ error) { - resp = &pbGroup.GetGroupMembersCMSResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (*pbGroup.GetGroupMembersCMSResp, error) { + resp := &pbGroup.GetGroupMembersCMSResp{CommonResp: &open_im_sdk.CommonResp{}} groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupID, req.UserName) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } log.NewInfo(req.OperationID, groupMembersCount) resp.MemberNums = int32(groupMembersCount) @@ -1347,20 +1118,14 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber, } - return + return resp, nil } -func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (resp *pbGroup.GetUserReqApplicationListResp, _ error) { - resp = &pbGroup.GetUserReqApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() +func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) { + resp := &pbGroup.GetUserReqApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} groupRequests, err := imdb.GetUserReqGroupByUserID(req.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } for _, groupReq := range groupRequests { node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}} @@ -1379,39 +1144,34 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou cp.GroupDBCopyOpenIM(node.GroupInfo, group) resp.GroupRequestList = append(resp.GroupRequestList, &node) } - return + return resp, nil } -func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (resp *pbGroup.DismissGroupResp, _ error) { - resp = &pbGroup.DismissGroupResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) { + resp := &pbGroup.DismissGroupResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) { - constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrIdentity, "") } if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := s.DelGroupAndUserCache(ctx, req.GroupID, nil); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err := imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusDismissed) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if groupInfo.GroupType != constant.SuperGroup { memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID) @@ -1436,22 +1196,20 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou } err = imdb.DeleteGroupMemberByGroupID(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupDismissedNotification(req) } else { err = db.DB.DeleteSuperGroup(req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } } - return + return resp, nil } -func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (resp *pbGroup.MuteGroupMemberResp, _ error) { - resp = &pbGroup.MuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) { + resp := &pbGroup.MuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1459,45 +1217,38 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou }() opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if opFlag == 0 { - constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) - return + return nil, err } mutedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID} groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano()) err = imdb.UpdateGroupMemberInfo(groupMemberInfo) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupMemberMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, req.MutedSeconds) - return + return resp, nil } -func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (resp *pbGroup.CancelMuteGroupMemberResp, _ error) { - resp = &pbGroup.CancelMuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) { + resp := &pbGroup.CancelMuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1506,45 +1257,38 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if opFlag == 0 { - constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) - return + return nil, err } mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID} groupMemberInfo.MuteEndTime = time.Unix(0, 0) err = imdb.UpdateGroupMemberInfo(groupMemberInfo) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupMemberCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) - return + return resp, nil } -func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (resp *pbGroup.MuteGroupResp, _ error) { - resp = &pbGroup.MuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) { + resp := &pbGroup.MuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1552,15 +1296,13 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) }() opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if opFlag == 0 { //errMsg := req.OperationID + "opFlag == 0 " + req.GroupID + req.OpUserID //log.Error(req.OperationID, errMsg) //return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil - constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrNoPermission, "") } //mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID) @@ -1577,22 +1319,20 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) // return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil //} if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusMuted) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupMutedNotification(req.OperationID, req.OpUserID, req.GroupID) - return + return resp, nil } -func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (resp *pbGroup.CancelMuteGroupResp, _ error) { - resp = &pbGroup.CancelMuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) { + resp := &pbGroup.CancelMuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1600,12 +1340,10 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu }() opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if opFlag == 0 { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } //mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.) //if err != nil { @@ -1622,28 +1360,25 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu //} log.Debug(req.OperationID, "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk}) if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } err = imdb.UpdateGroupInfoDefaultZero(req.GroupID, map[string]interface{}{"status": constant.GroupOk}) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID) - return + return resp, nil } -func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (resp *pbGroup.SetGroupMemberNicknameResp, _ error) { - resp = &pbGroup.SetGroupMemberNicknameResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) { + resp := &pbGroup.SetGroupMemberNicknameResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) { - constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) - return + return nil, utils.Wrap(constant.ErrIdentity, "") } cbReq := &pbGroup.SetGroupMemberInfoReq{ GroupID: req.GroupID, @@ -1653,8 +1388,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S Nickname: &wrapperspb.StringValue{Value: req.Nickname}, } if err := CallbackBeforeSetGroupMemberInfo(ctx, cbReq); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } nickName := cbReq.Nickname.Value groupMemberInfo := imdb.GroupMember{} @@ -1663,8 +1397,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S if nickName == "" { userNickname, err := imdb.GetUserNameByUserID(groupMemberInfo.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMemberInfo.Nickname = userNickname } else { @@ -1672,32 +1405,28 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S } if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := imdb.UpdateGroupMemberInfo(groupMemberInfo); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) - return + return resp, nil } -func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (resp *pbGroup.SetGroupMemberInfoResp, _ error) { - resp = &pbGroup.SetGroupMemberInfoResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) { + resp := &pbGroup.SetGroupMemberInfoResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) trace_log.ShowLog(ctx) }() if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } groupMember := imdb.GroupMember{ GroupID: req.GroupID, @@ -1719,8 +1448,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr m["ex"] = nil } if err := imdb.UpdateGroupMemberInfoByMap(groupMember, m); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } if req.RoleLevel != nil { switch req.RoleLevel.Value { @@ -1734,11 +1462,11 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr } else { chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) } - return + return resp, nil } -func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (resp *pbGroup.GetGroupAbstractInfoResp, _ error) { - resp = &pbGroup.GetGroupAbstractInfoResp{CommonResp: &open_im_sdk.CommonResp{}} +func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) { + resp := &pbGroup.GetGroupAbstractInfoResp{CommonResp: &open_im_sdk.CommonResp{}} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1746,14 +1474,12 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get }() hashCode, err := rocksCache.GetGroupMemberListHashFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } resp.GroupMemberListHash = hashCode num, err := rocksCache.GetGroupMemberNumFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return + return nil, err } resp.GroupMemberNumber = int32(num) return resp, nil From 9058c96ea43f170cb69e3b80de4c4119e913ca89 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 14:53:11 +0800 Subject: [PATCH 3/7] group rpc CommonResp --- internal/rpc/group/group.go | 47 ++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 52e236655..353c5fe3c 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -223,7 +223,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR } func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJoinedGroupListReq) (*pbGroup.GetJoinedGroupListResp, error) { - resp := &pbGroup.GetJoinedGroupListResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetJoinedGroupListResp{} if err := token_verify.CheckAccessV2(ctx, req.OpUserID, req.FromUserID); err != nil { return nil, err @@ -271,7 +271,7 @@ 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{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.InviteUserToGroupResp{} if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) { constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) @@ -386,7 +386,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite } func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) { - resp := &pbGroup.GetGroupAllMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupAllMemberResp{} groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { @@ -407,7 +407,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro } func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) { - resp := &pbGroup.GetGroupMemberListResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupMemberListResp{} memberList, err := imdb.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30) if err != nil { @@ -449,7 +449,7 @@ func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) { } func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) { - resp := &pbGroup.KickGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.KickGroupMemberResp{} groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) if err != nil { @@ -563,7 +563,7 @@ 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{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupMembersInfoResp{} resp.MemberList = []*open_im_sdk.GroupMemberFullInfo{} for _, userID := range req.MemberList { groupMember, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, userID) @@ -602,7 +602,7 @@ func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sd } func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) { - resp := &pbGroup.GetGroupApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupApplicationListResp{} reply, err := imdb.GetRecvGroupApplicationList(req.FromUserID) if err != nil { return nil, err @@ -635,7 +635,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{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupsInfoResp{} groupsInfoList := make([]*open_im_sdk.GroupInfo, 0) for _, groupID := range req.GroupIDList { groupInfoFromRedis, err := rocksCache.GetGroupInfoFromCache(ctx, groupID) @@ -663,7 +663,7 @@ func CheckPermission(ctx context.Context, groupID string, userID string) (err er } func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) { - resp := &pbGroup.GroupApplicationResponseResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GroupApplicationResponseResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -741,7 +741,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup } func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) { - resp := &pbGroup.JoinGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.JoinGroupResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -823,7 +823,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) } func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) { - resp := &pbGroup.QuitGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.QuitGroupResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -879,7 +879,7 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool { } func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) { - resp := &pbGroup.SetGroupInfoResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.SetGroupInfoResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -998,7 +998,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf } func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) { - resp := &pbGroup.TransferGroupOwnerResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.TransferGroupOwnerResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1041,7 +1041,6 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) { resp := &pbGroup.GetGroupsResp{ - CommonResp: &open_im_sdk.CommonResp{}, Groups: []*pbGroup.CMSGroup{}, Pagination: &open_im_sdk.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}, } @@ -1096,7 +1095,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) } func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (*pbGroup.GetGroupMembersCMSResp, error) { - resp := &pbGroup.GetGroupMembersCMSResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupMembersCMSResp{} groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) if err != nil { return nil, err @@ -1122,7 +1121,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr } func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) { - resp := &pbGroup.GetUserReqApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetUserReqApplicationListResp{} groupRequests, err := imdb.GetUserReqGroupByUserID(req.UserID) if err != nil { return nil, err @@ -1148,7 +1147,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou } func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) { - resp := &pbGroup.DismissGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.DismissGroupResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1209,7 +1208,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou } func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) { - resp := &pbGroup.MuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.MuteGroupMemberResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1248,7 +1247,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou } func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) { - resp := &pbGroup.CancelMuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.CancelMuteGroupMemberResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1288,7 +1287,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca } func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) { - resp := &pbGroup.MuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.MuteGroupResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1332,7 +1331,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) } func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) { - resp := &pbGroup.CancelMuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.CancelMuteGroupResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1371,7 +1370,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu } func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) { - resp := &pbGroup.SetGroupMemberNicknameResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.SetGroupMemberNicknameResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1416,7 +1415,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S } func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) { - resp := &pbGroup.SetGroupMemberInfoResp{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.SetGroupMemberInfoResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) @@ -1466,7 +1465,7 @@ 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{CommonResp: &open_im_sdk.CommonResp{}} + resp := &pbGroup.GetGroupAbstractInfoResp{} ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) defer func() { trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) From b2460d5267bc02b2217ed1f2a9f1938629fc14e1 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 14:57:44 +0800 Subject: [PATCH 4/7] group rpc --- internal/rpc/group/group.go | 82 ++++++------------------------------- 1 file changed, 12 insertions(+), 70 deletions(-) diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 353c5fe3c..84fbd0bae 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -664,11 +664,7 @@ func CheckPermission(ctx context.Context, groupID string, userID string) (err er func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) { resp := &pbGroup.GroupApplicationResponseResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if err := CheckPermission(ctx, req.GroupID, req.OpUserID); err != nil { return nil, err } @@ -742,11 +738,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) { resp := &pbGroup.JoinGroupResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if _, err := imdb.GetUserByUserID(req.OpUserID); err != nil { return nil, err } @@ -824,11 +816,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq) (*pbGroup.QuitGroupResp, error) { resp := &pbGroup.QuitGroupResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { return nil, err @@ -880,11 +868,7 @@ func hasAccess(req *pbGroup.SetGroupInfoReq) bool { func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) { resp := &pbGroup.SetGroupInfoResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if !hasAccess(req) { return nil, utils.Wrap(constant.ErrIdentity, "") } @@ -999,11 +983,6 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) { resp := &pbGroup.TransferGroupOwnerResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { @@ -1044,11 +1023,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) Groups: []*pbGroup.CMSGroup{}, Pagination: &open_im_sdk.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}, } - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if req.GroupID != "" { groupInfoDB, err := imdb.GetGroupInfoByGroupID(req.GroupID) if err != nil { @@ -1148,11 +1123,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) { resp := &pbGroup.DismissGroupResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) { return nil, utils.Wrap(constant.ErrIdentity, "") } @@ -1209,11 +1180,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) { resp := &pbGroup.MuteGroupMemberResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { return nil, err @@ -1248,11 +1215,6 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) { resp := &pbGroup.CancelMuteGroupMemberResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { @@ -1288,11 +1250,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) { resp := &pbGroup.MuteGroupResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { return nil, err @@ -1332,11 +1290,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) { resp := &pbGroup.CancelMuteGroupResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) if err != nil { return nil, err @@ -1371,11 +1325,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) { resp := &pbGroup.SetGroupMemberNicknameResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) { return nil, utils.Wrap(constant.ErrIdentity, "") } @@ -1416,11 +1366,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) { resp := &pbGroup.SetGroupMemberInfoResp{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { return nil, err } @@ -1466,11 +1412,7 @@ 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{} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String()) - trace_log.ShowLog(ctx) - }() + hashCode, err := rocksCache.GetGroupMemberListHashFromCache(ctx, req.GroupID) if err != nil { return nil, err From e8de74f76d87c3c03833d2c8d7721eb80a420681 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 15:33:32 +0800 Subject: [PATCH 5/7] group rpc --- pkg/common/middleware/rpc.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkg/common/middleware/rpc.go b/pkg/common/middleware/rpc.go index c1282bbb4..75b94d64e 100644 --- a/pkg/common/middleware/rpc.go +++ b/pkg/common/middleware/rpc.go @@ -62,9 +62,9 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary } func RpcClientInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) { - if cc == nil { - return utils.Wrap(constant.ErrRpcConn, "") - } + //if cc == nil { + // return utils.Wrap(constant.ErrRpcConn, "") + //} operationID, ok := ctx.Value("operationID").(string) if !ok { return utils.Wrap(constant.ErrArgs, "ctx missing operationID") From 5669399b2d064cbcdf041c76e3e54a4db26c94e9 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 15:56:49 +0800 Subject: [PATCH 6/7] group rpc --- internal/api_to_rpc/api.go | 1 - 1 file changed, 1 deletion(-) diff --git a/internal/api_to_rpc/api.go b/internal/api_to_rpc/api.go index 43cbc9d48..e77f8d340 100644 --- a/internal/api_to_rpc/api.go +++ b/internal/api_to_rpc/api.go @@ -1,7 +1,6 @@ package common import ( - "Open_IM/internal/fault_tolerant" "Open_IM/pkg/common/constant" "Open_IM/pkg/common/trace_log" utils2 "Open_IM/pkg/utils" From 920fcc14f1874d2a5d3326c01decbae8b542b176 Mon Sep 17 00:00:00 2001 From: withchao <993506633@qq.com> Date: Wed, 11 Jan 2023 16:16:44 +0800 Subject: [PATCH 7/7] api to rpc --- internal/api_to_rpc/api.go | 106 ++++++++++++++++++++++++++--------- pkg/common/middleware/gin.go | 1 + 2 files changed, 80 insertions(+), 27 deletions(-) diff --git a/internal/api_to_rpc/api.go b/internal/api_to_rpc/api.go index e77f8d340..b736bac37 100644 --- a/internal/api_to_rpc/api.go +++ b/internal/api_to_rpc/api.go @@ -1,24 +1,22 @@ package common import ( - "Open_IM/pkg/common/constant" "Open_IM/pkg/common/trace_log" utils2 "Open_IM/pkg/utils" - "context" utils "github.com/OpenIMSDK/open_utils" "github.com/gin-gonic/gin" + "google.golang.org/grpc/metadata" "reflect" ) func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn interface{}, rpcFuncName string, tokenFunc func(token string, operationID string) (string, error)) { + operationID := c.GetHeader("operationID") 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 := utils2.GetConn(c, rpcName) @@ -39,23 +37,14 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn in 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 } + md := metadata.Pairs("operationID", operationID, "opUserID", opUserID) respArr := rpc.Call([]reflect.Value{ - reflect.ValueOf(context.Context(c)), // context.Context - rpcReqPtr, // rpc apiReq + reflect.ValueOf(metadata.NewOutgoingContext(c, md)), // context.Context + rpcReqPtr, // rpc apiReq }) // respArr => (apiResp, error) if !respArr[1].IsNil() { // rpc err != nil err := respArr[1].Interface().(error) @@ -64,17 +53,6 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn in } 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", &constant.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) @@ -83,3 +61,77 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn in } trace_log.SetSuccess(nCtx, rpcFuncName, apiResp) } + +//func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, fn interface{}, rpcFuncName string, tokenFunc func(token string, operationID 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 := utils2.GetConn(c, rpcName) +// 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"), operationID) +// 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", &constant.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) +//} diff --git a/pkg/common/middleware/gin.go b/pkg/common/middleware/gin.go index c25b0c3fc..8155086cd 100644 --- a/pkg/common/middleware/gin.go +++ b/pkg/common/middleware/gin.go @@ -33,6 +33,7 @@ func GinParseOperationID(c *gin.Context) { } c.Request.Body = ioutil.NopCloser(bytes.NewReader(body)) operationID = req.OperationID + c.Request.Header.Set("operationID", operationID) } c.Set("operationID", operationID) c.Next()