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

 Conflicts:

	cmd/rpc/auth/main.go

	cmd/rpc/friend/main.go

	cmd/rpc/group/main.go

	cmd/rpc/msg/main.go

	cmd/rpc/user/main.go

	internal/rpc/auth/auth.go

	internal/rpc/conversation/conversaion.go

	internal/rpc/friend/friend.go

	internal/rpc/group/callback.go

	internal/rpc/group/group.go

	internal/rpc/msg/pull_message.go

	internal/rpc/msg/query_msg.go

	internal/rpc/msg/rpc_chat.go

	internal/rpc/msg/send_msg.go

	internal/rpc/user/user.go

	pkg/common/db/cache/redis.go

	pkg/common/db/controller/msg.go

	pkg/common/http/http_client.go

internal/rpc/auth/auth.go

@@ -2,70 +2,47 @@ package auth
 
 import (
 	"Open_IM/internal/common/check"
-	"Open_IM/internal/common/rpc_server"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
+	"Open_IM/pkg/common/db/relation"
+	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	pbAuth "Open_IM/pkg/proto/auth"
 	pbRelay "Open_IM/pkg/proto/relay"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
-func NewRpcAuthServer(port int) *rpcAuth {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImAuthName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	var redis cache.RedisClient
-	redis.InitRedis()
-	return &rpcAuth{
-		RpcServer:     r,
-		AuthInterface: controller.NewAuthController(redis.GetClient(), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
+	if err := mysql.AutoMigrate(&relationTb.FriendModel{}, &relationTb.FriendRequestModel{}, &relationTb.BlackModel{}); err != nil {
+		return err
 	}
+	redis, err := cache.NewRedis()
+	if err != nil {
+		return err
+	}
+	pbAuth.RegisterAuthServer(server, &authServer{
+		userCheck:      check.NewUserCheck(client),
+		RegisterCenter: client,
+		AuthInterface:  controller.NewAuthController(redis.GetClient(), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
+	})
+	return nil
 }
 
-func (s *rpcAuth) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "rpc auth start...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "listen network success ", listener, address)
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		prome.NewUserRegisterCounter()
-		prome.NewUserLoginCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	pbAuth.RegisterAuthServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "rpc auth ok")
-}
-
-func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
+func (s *authServer) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbAuth.UserTokenResp, error) {
 	resp := pbAuth.UserTokenResp{}
-	if _, err := check.GetUsersInfo(ctx, req.UserID); err != nil {
+	if _, err := s.userCheck.GetUsersInfo(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	token, err := s.CreateToken(ctx, req.UserID, constant.PlatformIDToName(int(req.PlatformID)))
@@ -77,7 +54,7 @@ func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbA
 	return &resp, nil
 }
 
-func (s *rpcAuth) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
+func (s *authServer) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
 	claims, err = tokenverify.GetClaimFromToken(tokensString)
 	if err != nil {
 		return nil, utils.Wrap(err, "")
@@ -102,7 +79,7 @@ func (s *rpcAuth) parseToken(ctx context.Context, tokensString string) (claims *
 	return nil, constant.ErrTokenNotExist.Wrap()
 }
 
-func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
+func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
 	resp = &pbAuth.ParseTokenResp{}
 	claims, err := s.parseToken(ctx, req.Token)
 	if err != nil {
@@ -114,7 +91,7 @@ func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (re
 	return resp, nil
 }
 
-func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {
+func (s *authServer) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {
 	resp := pbAuth.ForceLogoutResp{}
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
@@ -125,7 +102,7 @@ func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (
 	return &resp, nil
 }
 
-func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID int32, operationID string) error {
+func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID int32, operationID string) error {
 	grpcCons, err := s.RegisterCenter.GetConns(config.Config.RpcRegisterName.OpenImRelayName)
 	if err != nil {
 		return err
@@ -140,7 +117,8 @@ func (s *rpcAuth) forceKickOff(ctx context.Context, userID string, platformID in
 	return constant.ErrInternalServer.Wrap()
 }
 
-type rpcAuth struct {
-	*rpcserver.RpcServer
+type authServer struct {
 	controller.AuthInterface
+	userCheck      *check.UserCheck
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
 }

internal/rpc/conversation/conversaion.go

@@ -6,11 +6,14 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
-	relationTb "Open_IM/pkg/common/db/relation"
-	unrealationTb "Open_IM/pkg/common/db/unrelation"
+	"Open_IM/pkg/common/db/relation"
+	tableRelation "Open_IM/pkg/common/db/table/relation"
+	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/prome"
+	promePkg "Open_IM/pkg/common/prometheus"
+	"Open_IM/pkg/getcdv3"
 	pbConversation "Open_IM/pkg/proto/conversation"
+	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
 	"github.com/dtm-labs/rockscache"
@@ -47,7 +50,7 @@ func NewConversationServer(port int) *conversationServer {
 	var cCache cache.ConversationCache
 	//mysql init
 	var mysql relation.Mysql
-	err := mysql.InitConn().AutoMigrateModel(&table.ConversationModel{})
+	err := mysql.InitConn().AutoMigrateModel(&tableRelation.ConversationModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
@@ -92,11 +95,11 @@ func (c *conversationServer) Run() {
 	//grpc server
 	var grpcOpts []grpc.ServerOption
 	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
+		promePkg.NewGrpcRequestCounter()
+		promePkg.NewGrpcRequestFailedCounter()
+		promePkg.NewGrpcRequestSuccessCounter()
 		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
+			// grpc.UnaryInterceptor(promePkg.UnaryServerInterceptorProme),
 			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
 			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
 		}...)
@@ -170,7 +173,7 @@ func (c *conversationServer) GetConversations(ctx context.Context, req *pbConver
 
 func (c *conversationServer) BatchSetConversations(ctx context.Context, req *pbConversation.BatchSetConversationsReq) (*pbConversation.BatchSetConversationsResp, error) {
 	resp := &pbConversation.BatchSetConversationsResp{}
-	var conversations []*table.ConversationModel
+	var conversations []*tableRelation.ConversationModel
 	if err := utils.CopyStructFields(&conversations, req.Conversations); err != nil {
 		return nil, err
 	}
@@ -203,16 +206,16 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 			return nil, err
 		}
 	}
-	var conversation table.ConversationModel
+	var conversation tableRelation.ConversationModel
 	if err := utils.CopyStructFields(&conversation, req.Conversation); err != nil {
 		return nil, err
 	}
 	if req.FieldType == constant.FieldIsPrivateChat {
-		err := c.ConversationInterface.SyncPeerUserPrivateConversationTx(ctx, req.Conversation)
+		err := c.ConversationInterface.SyncPeerUserPrivateConversationTx(ctx, &conversation)
 		if err != nil {
 			return nil, err
 		}
-		chat.ConversationSetPrivateNotification(req.OperationID, req.Conversation.OwnerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat)
+		chat.ConversationSetPrivateNotification(ctx, req.Conversation.OwnerUserID, req.Conversation.UserID, req.Conversation.IsPrivateChat)
 		return resp, nil
 	}
 	//haveUserID, err := c.ConversationInterface.GetUserIDExistConversation(ctx, req.UserIDList, req.Conversation.ConversationID)
@@ -239,29 +242,18 @@ func (c *conversationServer) ModifyConversationField(ctx context.Context, req *p
 	case constant.FieldBurnDuration:
 		filedMap["burn_duration"] = req.Conversation.BurnDuration
 	}
-	c.ConversationInterface.SetUsersConversationFiledTx(ctx, req.UserIDList, &conversation, filedMap)
-	err = c.ConversationInterface.UpdateUsersConversationFiled(ctx, haveUserID, req.Conversation.ConversationID, filedMap)
-	if err != nil {
-		return nil, err
-	}
-	var conversations []*pbConversation.Conversation
-	for _, v := range utils.DifferenceString(haveUserID, req.UserIDList) {
-		temp := new(pbConversation.Conversation)
-		_ = utils.CopyStructFields(temp, req.Conversation)
-		temp.OwnerUserID = v
-		conversations = append(conversations, temp)
-	}
-	err = c.ConversationInterface.CreateConversation(ctx, conversations)
+	err = c.ConversationInterface.SetUsersConversationFiledTx(ctx, req.UserIDList, &conversation, filedMap)
 	if err != nil {
 		return nil, err
 	}
+
 	if isSyncConversation {
 		for _, v := range req.UserIDList {
-			chat.ConversationChangeNotification(req.OperationID, v)
+			chat.ConversationChangeNotification(ctx, v)
 		}
 	} else {
 		for _, v := range req.UserIDList {
-			chat.ConversationUnreadChangeNotification(req.OperationID, v, req.Conversation.ConversationID, req.Conversation.UpdateUnreadCountTime)
+			chat.ConversationUnreadChangeNotification(ctx, v, req.Conversation.ConversationID, req.Conversation.UpdateUnreadCountTime)
 		}
 	}
 	return resp, nil

internal/rpc/friend/black.go

@@ -1,9 +1,7 @@
 package friend
 
 import (
-	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	chat "Open_IM/internal/rpc/msg"
 	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
@@ -13,14 +11,14 @@ import (
 
 func (s *friendServer) GetPaginationBlacks(ctx context.Context, req *pbFriend.GetPaginationBlacksReq) (resp *pbFriend.GetPaginationBlacksResp, err error) {
 	resp = &pbFriend.GetPaginationBlacksResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	blacks, total, err := s.BlackInterface.FindOwnerBlacks(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.Blacks, err = (*convert.DBBlack)(nil).DB2PB(blacks)
+	resp.Blacks, err = (*convert.NewDBBlack(nil, s.RegisterCenter)).DB2PB(ctx, blacks)
 	if err != nil {
 		return nil, err
 	}
@@ -41,13 +39,13 @@ func (s *friendServer) IsBlack(ctx context.Context, req *pbFriend.IsBlackReq) (*
 
 func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlackReq) (*pbFriend.RemoveBlackResp, error) {
 	resp := &pbFriend.RemoveBlackResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	if err := s.BlackInterface.Delete(ctx, []*relation.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
 		return nil, err
 	}
-	chat.BlackDeletedNotification(ctx, req)
+	s.notification.BlackDeletedNotification(ctx, req)
 	return resp, nil
 }
 
@@ -60,6 +58,6 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err := s.BlackInterface.Create(ctx, []*relation.BlackModel{&black}); err != nil {
 		return nil, err
 	}
-	chat.BlackAddedNotification(ctx, req)
+	s.notification.BlackAddedNotification(ctx, req)
 	return resp, nil
 }

internal/rpc/friend/callback.go

@@ -1,59 +1,26 @@
 package friend
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
+	pbfriend "Open_IM/pkg/proto/friend"
 	"context"
-
-	//"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	http2 "net/http"
 )
 
-func callbackBeforeAddFriendV1(ctx context.Context, req *pbFriend.AddFriendReq) error {
-	resp := callbackBeforeAddFriend(ctx, req)
-	if resp.ErrCode != 0 {
-		return (&constant.ErrInfo{
-			ErrCode: resp.ErrCode,
-			ErrMsg:  resp.ErrMsg,
-		}).Wrap()
-	}
-	return nil
-}
-
-func callbackBeforeAddFriend(ctx context.Context, req *pbFriend.AddFriendReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: tracelog.GetOperationID(ctx)}
+func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) error {
 	if !config.Config.Callback.CallbackBeforeAddFriend.Enable {
-		return callbackResp
+		return nil
 	}
-
-	commonCallbackReq := &cbApi.CallbackBeforeAddFriendReq{
+	cbReq := &cbapi.CallbackBeforeAddFriendReq{
 		CallbackCommand: constant.CallbackBeforeAddFriendCommand,
 		FromUserID:      req.FromUserID,
 		ToUserID:        req.ToUserID,
 		ReqMsg:          req.ReqMsg,
 		OperationID:     tracelog.GetOperationID(ctx),
 	}
-	resp := &cbApi.CallbackBeforeAddFriendResp{
-		CommonCallbackResp: &callbackResp,
-	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), commonCallbackReq, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeAddFriendCommand, commonCallbackReq, resp, config.Config.Callback.CallbackBeforeAddFriend); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !*config.Config.Callback.CallbackBeforeAddFriend.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeAddFriendResp{}
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeAddFriend)
 }

internal/rpc/friend/friend.go

@@ -3,110 +3,60 @@ package friend
 import (
 	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	"Open_IM/internal/common/rpc_server"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	relationTb "Open_IM/pkg/common/db/table/relation"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/middleware"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	pbfriend "Open_IM/pkg/proto/friend"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
 type friendServer struct {
-	*rpcserver.RpcServer
-
 	controller.FriendInterface
 	controller.BlackInterface
+	notification   *notification.Check
+	userCheck      *check.UserCheck
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
 }
 
-func NewFriendServer(port int) *friendServer {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImFriendName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	//mysql init
-	var mysql relation.Mysql
-	var model relation.FriendGorm
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.FriendRequestModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	err = mysql.InitConn().AutoMigrateModel(&relationTb.BlackModel{})
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	if mysql.GormConn() != nil {
-		model.DB = mysql.GormConn()
-	} else {
-		panic("db init err:" + "conn is nil")
-	}
-	return &friendServer{
-		RpcServer:       r,
-		FriendInterface: controller.NewFriendController(model.DB),
-		BlackInterface:  controller.NewBlackController(model.DB),
-	}
-}
-
-func (s *friendServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "friendServer run...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-
-	log.NewInfo(operationID, "listen ok ", address)
-	defer listener.Close()
-	//grpc server
-	var grpcOpts []grpc.ServerOption
-	grpcOpts = append(grpcOpts, grpc.UnaryInterceptor(middleware.RpcServerInterceptor))
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	pbFriend.RegisterFriendServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError(operationID, "Serve failed ", err.Error(), listener)
-		return
+	if err := mysql.AutoMigrate(&relationTb.FriendModel{}, &relationTb.FriendRequestModel{}, &relationTb.BlackModel{}); err != nil {
+		return err
 	}
+	pbfriend.RegisterFriendServer(server, &friendServer{
+		FriendInterface: controller.NewFriendController(mysql),
+		BlackInterface:  controller.NewBlackController(mysql),
+		notification:    notification.NewCheck(client),
+		userCheck:       check.NewUserCheck(client),
+		RegisterCenter:  client,
+	})
+	return nil
 }
 
 // ok
-func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbFriend.ApplyToAddFriendReq) (resp *pbFriend.ApplyToAddFriendResp, err error) {
-	resp = &pbFriend.ApplyToAddFriendResp{}
+func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriendReq) (resp *pbfriend.ApplyToAddFriendResp, err error) {
+	resp = &pbfriend.ApplyToAddFriendResp{}
 	if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
 		return nil, err
 	}
-	if err := callbackBeforeAddFriendV1(ctx, req); err != nil {
+	if err := CallbackBeforeAddFriend(ctx, req); err != nil {
 		return nil, err
 	}
 	if req.ToUserID == req.FromUserID {
 		return nil, constant.ErrCanNotAddYourself.Wrap()
 	}
-	if _, err := check.GetUsersInfo(ctx, req.ToUserID, req.FromUserID); err != nil {
+	if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil {
 		return nil, err
 	}
 	in1, in2, err := s.FriendInterface.CheckIn(ctx, req.FromUserID, req.ToUserID)
@@ -119,17 +69,17 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbFriend.Apply
 	if err = s.FriendInterface.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
 		return nil, err
 	}
-	chat.FriendApplicationAddNotification(ctx, req)
+	s.notification.FriendApplicationAddNotification(ctx, req)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFriendReq) (resp *pbFriend.ImportFriendResp, err error) {
-	resp = &pbFriend.ImportFriendResp{}
+func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFriendReq) (resp *pbfriend.ImportFriendResp, err error) {
+	resp = &pbfriend.ImportFriendResp{}
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
 	}
-	if _, err := check.GetUsersInfo(ctx, req.OwnerUserID, req.FriendUserIDs); err != nil {
+	if _, err := s.userCheck.GetUsersInfos(ctx, append([]string{req.OwnerUserID}, req.FriendUserIDs...), true); err != nil {
 		return nil, err
 	}
 
@@ -147,9 +97,9 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFr
 }
 
 // ok
-func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.RespondFriendApplyReq) (resp *pbFriend.RespondFriendApplyResp, err error) {
-	resp = &pbFriend.RespondFriendApplyResp{}
-	if err := check.Access(ctx, req.ToUserID); err != nil {
+func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.RespondFriendApplyReq) (resp *pbfriend.RespondFriendApplyResp, err error) {
+	resp = &pbfriend.RespondFriendApplyResp{}
+	if err := s.userCheck.Access(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}
 	friendRequest := relationTb.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
@@ -158,7 +108,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 		if err != nil {
 			return nil, err
 		}
-		chat.FriendApplicationAgreedNotification(ctx, req)
+		s.notification.FriendApplicationAgreedNotification(ctx, req)
 		return resp, nil
 	}
 	if req.HandleResult == constant.FriendResponseRefuse {
@@ -166,16 +116,16 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 		if err != nil {
 			return nil, err
 		}
-		chat.FriendApplicationRefusedNotification(ctx, req)
+		s.notification.FriendApplicationRefusedNotification(ctx, req)
 		return resp, nil
 	}
 	return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1")
 }
 
 // ok
-func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFriendReq) (resp *pbFriend.DeleteFriendResp, err error) {
-	resp = &pbFriend.DeleteFriendResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+func (s *friendServer) DeleteFriend(ctx context.Context, req *pbfriend.DeleteFriendReq) (resp *pbfriend.DeleteFriendResp, err error) {
+	resp = &pbfriend.DeleteFriendResp{}
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
@@ -185,14 +135,14 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
 	if err := s.FriendInterface.Delete(ctx, req.OwnerUserID, []string{req.FriendUserID}); err != nil {
 		return nil, err
 	}
-	chat.FriendDeletedNotification(ctx, req)
+	s.notification.FriendDeletedNotification(ctx, req)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFriendRemarkReq) (resp *pbFriend.SetFriendRemarkResp, err error) {
-	resp = &pbFriend.SetFriendRemarkResp{}
-	if err := check.Access(ctx, req.OwnerUserID); err != nil {
+func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbfriend.SetFriendRemarkReq) (resp *pbfriend.SetFriendRemarkResp, err error) {
+	resp = &pbfriend.SetFriendRemarkResp{}
+	if err := s.userCheck.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
 	_, err = s.FindFriendsWithError(ctx, req.OwnerUserID, []string{req.FriendUserID})
@@ -202,21 +152,21 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
 	if err := s.FriendInterface.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
 		return nil, err
 	}
-	chat.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
+	s.notification.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
 	return resp, nil
 }
 
 // ok
-func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbFriend.GetDesignatedFriendsReq) (resp *pbFriend.GetDesignatedFriendsResp, err error) {
-	resp = &pbFriend.GetDesignatedFriendsResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.GetDesignatedFriendsReq) (resp *pbfriend.GetDesignatedFriendsResp, err error) {
+	resp = &pbfriend.GetDesignatedFriendsResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friends, total, err := s.FriendInterface.PageOwnerFriends(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendsInfo, err = (*convert.DBFriend)(nil).DB2PB(friends)
+	resp.FriendsInfo, err = (*convert.NewDBFriend(nil, s.RegisterCenter)).DB2PB(ctx, friends)
 	if err != nil {
 		return nil, err
 	}
@@ -225,16 +175,16 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbFriend.G
 }
 
 // ok 获取接收到的好友申请（即别人主动申请的）
-func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbFriend.GetPaginationFriendsApplyToReq) (resp *pbFriend.GetPaginationFriendsApplyToResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsApplyToResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyToReq) (resp *pbfriend.GetPaginationFriendsApplyToResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsApplyToResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friendRequests, total, err := s.FriendInterface.PageFriendRequestToMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendRequests, err = (*convert.DBFriendRequest)(nil).DB2PB(friendRequests)
+	resp.FriendRequests, err = (*convert.NewDBFriendRequest(nil, s.RegisterCenter)).DB2PB(ctx, friendRequests)
 	if err != nil {
 		return nil, err
 	}
@@ -243,16 +193,16 @@ func (s *friendServer) GetPaginationFriendsApplyTo(ctx context.Context, req *pbF
 }
 
 // ok 获取主动发出去的好友申请列表
-func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *pbFriend.GetPaginationFriendsApplyFromReq) (resp *pbFriend.GetPaginationFriendsApplyFromResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsApplyFromResp{}
-	if err := check.Access(ctx, req.UserID); err != nil {
+func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *pbfriend.GetPaginationFriendsApplyFromReq) (resp *pbfriend.GetPaginationFriendsApplyFromResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsApplyFromResp{}
+	if err := s.userCheck.Access(ctx, req.UserID); err != nil {
 		return nil, err
 	}
 	friendRequests, total, err := s.FriendInterface.PageFriendRequestFromMe(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
-	resp.FriendRequests, err = (*convert.DBFriendRequest)(nil).DB2PB(friendRequests)
+	resp.FriendRequests, err = (*convert.NewDBFriendRequest(nil, s.RegisterCenter)).DB2PB(ctx, friendRequests)
 	if err != nil {
 		return nil, err
 	}
@@ -261,8 +211,8 @@ func (s *friendServer) GetPaginationFriendsApplyFrom(ctx context.Context, req *p
 }
 
 // ok
-func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq) (resp *pbFriend.IsFriendResp, err error) {
-	resp = &pbFriend.IsFriendResp{}
+func (s *friendServer) IsFriend(ctx context.Context, req *pbfriend.IsFriendReq) (resp *pbfriend.IsFriendResp, err error) {
+	resp = &pbfriend.IsFriendResp{}
 	resp.InUser1Friends, resp.InUser2Friends, err = s.FriendInterface.CheckIn(ctx, req.UserID1, req.UserID2)
 	if err != nil {
 		return nil, err
@@ -271,8 +221,8 @@ func (s *friendServer) IsFriend(ctx context.Context, req *pbFriend.IsFriendReq)
 }
 
 // ok
-func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbFriend.GetPaginationFriendsReq) (resp *pbFriend.GetPaginationFriendsResp, err error) {
-	resp = &pbFriend.GetPaginationFriendsResp{}
+func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbfriend.GetPaginationFriendsReq) (resp *pbfriend.GetPaginationFriendsResp, err error) {
+	resp = &pbfriend.GetPaginationFriendsResp{}
 	if utils.Duplicate(req.FriendUserIDs) {
 		return nil, constant.ErrArgs.Wrap("friend userID repeated")
 	}
@@ -280,7 +230,7 @@ func (s *friendServer) GetPaginationFriends(ctx context.Context, req *pbFriend.G
 	if err != nil {
 		return nil, err
 	}
-	if resp.FriendsInfo, err = (*convert.DBFriend)(nil).DB2PB(friends); err != nil {
+	if resp.FriendsInfo, err = (*convert.NewDBFriend(nil, s.RegisterCenter)).DB2PB(ctx, friends); err != nil {
 		return nil, err
 	}
 	return resp, nil

internal/rpc/group/callback.go

@@ -1,167 +1,139 @@
 package group
 
 import (
+	"Open_IM/pkg/apistruct"
 	"Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/tracelog"
-	pbGroup "Open_IM/pkg/proto/group"
+	"Open_IM/pkg/proto/group"
 	"Open_IM/pkg/utils"
 	"context"
 	"google.golang.org/protobuf/types/known/wrapperspb"
+	"time"
 )
 
-func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
-	}()
+func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (err error) {
 	if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
 		return nil
 	}
-	commonCallbackReq := &cbApi.CallbackBeforeCreateGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
+	}()
+	cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
-		OperationID:     req.OperationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupInfo:       *req.GroupInfo,
-		InitMemberList:  req.InitMemberList,
 	}
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
-	resp := &cbApi.CallbackBeforeCreateGroupResp{
-		CommonCallbackResp: &callbackResp,
+	cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+		UserID:    req.OwnerUserID,
+		RoleLevel: constant.GroupOwner,
+	})
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupAdmin,
+		})
 	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(req.OperationID, utils.GetSelfFuncName(), commonCallbackReq, *resp)
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeCreateGroupCommand, commonCallbackReq,
-		resp, config.Config.Callback.CallbackBeforeCreateGroup)
-	if err == nil {
-		if resp.GroupID != nil {
-			req.GroupInfo.GroupID = *resp.GroupID
-		}
-		if resp.GroupName != nil {
-			req.GroupInfo.GroupName = *resp.GroupName
-		}
-		if resp.Notification != nil {
-			req.GroupInfo.Notification = *resp.Notification
-		}
-		if resp.Introduction != nil {
-			req.GroupInfo.Introduction = *resp.Introduction
-		}
-		if resp.FaceURL != nil {
-			req.GroupInfo.FaceURL = *resp.FaceURL
-		}
-		if resp.OwnerUserID != nil {
-			req.GroupInfo.OwnerUserID = *resp.OwnerUserID
-		}
-		if resp.Ex != nil {
-			req.GroupInfo.Ex = *resp.Ex
-		}
-		if resp.Status != nil {
-			req.GroupInfo.Status = *resp.Status
-		}
-		if resp.CreatorUserID != nil {
-			req.GroupInfo.CreatorUserID = *resp.CreatorUserID
-		}
-		if resp.GroupType != nil {
-			req.GroupInfo.GroupType = *resp.GroupType
-		}
-		if resp.NeedVerification != nil {
-			req.GroupInfo.NeedVerification = *resp.NeedVerification
-		}
-		if resp.LookMemberInfo != nil {
-			req.GroupInfo.LookMemberInfo = *resp.LookMemberInfo
-		}
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupOrdinaryUsers,
+		})
 	}
-	return err
+	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	if err != nil {
+		return err
+	}
+	utils.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
+	utils.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
+	utils.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
+	utils.NotNilReplace(&req.GroupInfo.Introduction, resp.Introduction)
+	utils.NotNilReplace(&req.GroupInfo.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&req.GroupInfo.OwnerUserID, resp.OwnerUserID)
+	utils.NotNilReplace(&req.GroupInfo.Ex, resp.Ex)
+	utils.NotNilReplace(&req.GroupInfo.Status, resp.Status)
+	utils.NotNilReplace(&req.GroupInfo.CreatorUserID, resp.CreatorUserID)
+	utils.NotNilReplace(&req.GroupInfo.GroupType, resp.GroupType)
+	utils.NotNilReplace(&req.GroupInfo.NeedVerification, resp.NeedVerification)
+	utils.NotNilReplace(&req.GroupInfo.LookMemberInfo, resp.LookMemberInfo)
+	return nil
 }
 
-func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
 	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
 		return nil
 	}
-	log.NewDebug(operationID, "args: ", *groupMember)
-	callbackReq := cbApi.CallbackBeforeMemberJoinGroupReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
+	}()
+	callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
 		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
-		OperationID:     operationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupID:         groupMember.GroupID,
 		UserID:          groupMember.UserID,
 		Ex:              groupMember.Ex,
 		GroupEx:         groupEx,
 	}
-	resp := &cbApi.CallbackBeforeMemberJoinGroupResp{
-		CommonCallbackResp: &callbackResp,
+	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
+	if err != nil {
+		return err
 	}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeMemberJoinGroupCommand, callbackReq,
-		resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
-	if err == nil {
-		if resp.MuteEndTime != nil {
-			groupMember.MuteEndTime = utils.UnixSecondToTime(*resp.MuteEndTime)
-		}
-		if resp.FaceURL != nil {
-			groupMember.FaceURL = *resp.FaceURL
-		}
-		if resp.Ex != nil {
-			groupMember.Ex = *resp.Ex
-		}
-		if resp.NickName != nil {
-			groupMember.Nickname = *resp.NickName
-		}
-		if resp.RoleLevel != nil {
-			groupMember.RoleLevel = *resp.RoleLevel
-		}
+	if resp.MuteEndTime != nil {
+		groupMember.MuteEndTime = time.UnixMilli(*resp.MuteEndTime)
 	}
-	return err
+	utils.NotNilReplace(&groupMember.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&groupMember.Ex, resp.Ex)
+	utils.NotNilReplace(&groupMember.Nickname, resp.Nickname)
+	utils.NotNilReplace(&groupMember.RoleLevel, resp.RoleLevel)
+	return nil
 }
 
-func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfo) (err error) {
-	defer func() {
-		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
-	}()
-	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMemberInfo) (err error) {
 	if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {
 		return nil
 	}
-	callbackReq := cbApi.CallbackBeforeSetGroupMemberInfoReq{
+	defer func() {
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
+	}()
+	callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
 		CallbackCommand: constant.CallbackBeforeSetGroupMemberInfoCommand,
-		OperationID:     req.OperationID,
+		OperationID:     tracelog.GetOperationID(ctx),
 		GroupID:         req.GroupID,
 		UserID:          req.UserID,
 	}
 	if req.Nickname != nil {
-		callbackReq.Nickname = req.Nickname.Value
+		callbackReq.Nickname = &req.Nickname.Value
 	}
 	if req.FaceURL != nil {
-		callbackReq.FaceURL = req.FaceURL.Value
+		callbackReq.FaceURL = &req.FaceURL.Value
 	}
 	if req.RoleLevel != nil {
-		callbackReq.RoleLevel = req.RoleLevel.Value
+		callbackReq.RoleLevel = &req.RoleLevel.Value
 	}
 	if req.Ex != nil {
-		callbackReq.Ex = req.Ex.Value
+		callbackReq.Ex = &req.Ex.Value
 	}
-	resp := &cbApi.CallbackBeforeSetGroupMemberInfoResp{
-		CommonCallbackResp: &callbackResp,
+	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
+	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	if err != nil {
+		return err
 	}
-	err = http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetGroupMemberInfoCommand, callbackReq,
-		resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSetGroupMemberInfo.CallbackFailedContinue)
-	if err == nil {
-		if resp.FaceURL != nil {
-			req.FaceURL = &wrapperspb.StringValue{Value: *resp.FaceURL}
-		}
-		if resp.Nickname != nil {
-			req.Nickname = &wrapperspb.StringValue{Value: *resp.Nickname}
-		}
-		if resp.RoleLevel != nil {
-			req.RoleLevel = &wrapperspb.Int32Value{Value: *resp.RoleLevel}
-		}
-		if resp.Ex != nil {
-			req.Ex = &wrapperspb.StringValue{Value: *resp.Ex}
-		}
+	if resp.FaceURL != nil {
+		req.FaceURL = wrapperspb.String(*resp.FaceURL)
 	}
-	return err
+	if resp.Nickname != nil {
+		req.Nickname = wrapperspb.String(*resp.Nickname)
+	}
+	if resp.RoleLevel != nil {
+		req.RoleLevel = wrapperspb.Int32(*resp.RoleLevel)
+	}
+	if resp.Ex != nil {
+		req.Ex = wrapperspb.String(*resp.Ex)
+	}
+	return nil
 }

internal/rpc/group/db_map.go

@@ -12,7 +12,7 @@ func UpdateGroupInfoMap(group *sdkws.GroupInfoForSet) map[string]any {
 		m["group_name"] = group.GroupName
 	}
 	if group.Notification != "" {
-		m["notification"] = group.Notification
+		m["Notification"] = group.Notification
 	}
 	if group.Introduction != "" {
 		m["introduction"] = group.Introduction

internal/rpc/group/g.go

@@ -1,94 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/tracelog"
-	pbConversation "Open_IM/pkg/proto/conversation"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"errors"
-	"math/big"
-	"strconv"
-	"strings"
-	"time"
-)
-
-func GetPublicUserInfoOne(ctx context.Context, userID string) (*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUsersInfo(ctx context.Context, userIDs []string) ([]*sdkws.UserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.UserInfo, error) {
-	users, err := GetUsersInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.UserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetPublicUserInfo(ctx context.Context, userIDs []string) ([]*sdkws.PublicUserInfo, error) {
-	return nil, errors.New("todo")
-}
-
-func GetPublicUserInfoMap(ctx context.Context, userIDs []string) (map[string]*sdkws.PublicUserInfo, error) {
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	return utils.SliceToMap(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	}), nil
-}
-
-func GetUsername(ctx context.Context, userIDs []string) (map[string]string, error) {
-	if len(userIDs) == 0 {
-		return map[string]string{}, nil
-	}
-	users, err := GetPublicUserInfo(ctx, userIDs)
-	if err != nil {
-		return nil, err
-	}
-	if ids := utils.Single(userIDs, utils.Slice(users, func(e *sdkws.PublicUserInfo) string {
-		return e.UserID
-	})); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	return utils.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, string) {
-		return e.UserID, e.Nickname
-	}), nil
-}
-
-func GroupNotification(ctx context.Context, groupID string) {
-	var conversationReq pbConversation.ModifyConversationFieldReq
-	conversation := pbConversation.Conversation{
-		OwnerUserID:      tracelog.GetOpUserID(ctx),
-		ConversationID:   utils.GetConversationIDBySessionType(groupID, constant.GroupChatType),
-		ConversationType: constant.GroupChatType,
-		GroupID:          groupID,
-	}
-	conversationReq.Conversation = &conversation
-	conversationReq.OperationID = tracelog.GetOperationID(ctx)
-	conversationReq.FieldType = constant.FieldGroupAtType
-	conversation.GroupAtType = constant.GroupNotification
-	conversationReq.UserIDList = cacheResp.UserIDList
-
-	_, err = pbConversation.NewConversationClient(s.etcdConn.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)).ModifyConversationField(ctx, &conversationReq)
-	tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
-}
-
-func genGroupID(ctx context.Context, groupID string) string {
-	if groupID != "" {
-		return groupID
-	}
-	groupID = utils.Md5(tracelog.GetOperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
-	bi := big.NewInt(0)
-	bi.SetString(groupID[0:8], 16)
-	groupID = bi.String()
-	return groupID
-}

internal/rpc/group/group.go

@@ -1,120 +1,61 @@
 package group
 
 import (
-	"Open_IM/internal/common/network"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/check"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	relationTb "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/db/unrelation"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/middleware"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
-	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	pbConversation "Open_IM/pkg/proto/conversation"
 	pbGroup "Open_IM/pkg/proto/group"
 	"Open_IM/pkg/proto/sdkws"
 	"Open_IM/pkg/utils"
 	"context"
 	"fmt"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-	"net"
+	"github.com/OpenIMSDK/openKeeper"
+	"google.golang.org/grpc"
+	"gorm.io/gorm"
+	"math/big"
+	"math/rand"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/OpenIMSDK/openKeeper"
-	"google.golang.org/grpc"
 )
 
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	db, err := relation.NewGormDB()
+	if err != nil {
+		return err
+	}
+	if err := db.AutoMigrate(&relationTb.GroupModel{}, &relationTb.GroupMemberModel{}, &relationTb.GroupRequestModel{}); err != nil {
+		return err
+	}
+	redis, err := cache.NewRedis()
+	if err != nil {
+		return err
+	}
+	mongo, err := unrelation.NewMongo()
+	if err != nil {
+		return err
+	}
+	pbGroup.RegisterGroupServer(server, &groupServer{
+		GroupInterface:      controller.NewGroupInterface(controller.NewGroupDatabase(db, redis.GetClient(), mongo.GetClient())),
+		UserCheck:           check.NewUserCheck(client),
+		ConversationChecker: check.NewConversationChecker(client),
+	})
+	return nil
+}
+
 type groupServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	schema          string
-	zkAddr          []string
-	GroupInterface  controller.GroupInterface
-	registerCenter  discoveryRegistry.SvcDiscoveryRegistry
-}
-
-func NewGroupServer(port int) *groupServer {
-	log.NewPrivateLog(constant.LogFileName)
-	g := groupServer{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
-		schema:          config.Config.Zookeeper.Schema,
-		zkAddr:          config.Config.Zookeeper.ZkAddr,
-	}
-	//mysql init
-	var mysql relation.Mysql
-	var mongo unrelation.Mongo
-	var groupModel relationTb.GroupModel
-	var redis cache.RedisClient
-	err := mysql.InitConn().AutoMigrateModel(&groupModel)
-	if err != nil {
-		panic("db init err:" + err.Error())
-	}
-	mongo.InitMongo()
-	redis.InitRedis()
-	mongo.CreateSuperGroupIndex()
-	zkClient, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, "", "")
-	if err != nil {
-		panic(err.Error())
-	}
-	registerIP, err := network.GetRpcRegisterIP(config.Config.RpcRegisterIP)
-	g.registerCenter = zkClient
-	err = g.registerCenter.Register(config.Config.RpcRegisterName.OpenImGroupName, registerIP, port)
-	if err != nil {
-		panic(err.Error())
-	}
-	//conns, err := g.registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
-	g.GroupInterface = controller.NewGroupInterface(mysql.GormConn(), redis.GetClient(), mongo.GetClient())
-	return &g
-}
-
-func (s *groupServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "group rpc start ")
-	address := network.GetListenIP(config.Config.ListenIP) + ":" + strconv.Itoa(s.rpcPort)
-	//listener network
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + s.rpcRegisterName)
-	}
-	log.NewInfo(operationID, "listen network success, ", address, listener)
-
-	defer listener.Close()
-	//grpc server
-	recvSize := 1024 * 1024 * constant.GroupRPCRecvSize
-	sendSize := 1024 * 1024 * constant.GroupRPCSendSize
-	var grpcOpts = []grpc.ServerOption{
-		grpc.MaxRecvMsgSize(recvSize),
-		grpc.MaxSendMsgSize(sendSize),
-		grpc.UnaryInterceptor(middleware.RpcServerInterceptor),
-	}
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbGroup.RegisterGroupServer(srv, s)
-	err = srv.Serve(listener)
-	if err != nil {
-		log.NewError(operationID, "Serve failed ", err.Error())
-		return
-	}
-	log.NewInfo(operationID, "group rpc success")
+	GroupInterface      controller.GroupInterface
+	UserCheck           *check.UserCheck
+	Notification        *notification.Check
+	ConversationChecker *check.ConversationChecker
 }
 
 func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
@@ -130,6 +71,52 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
+func (s *groupServer) GetUsernameMap(ctx context.Context, userIDs []string, complete bool) (map[string]string, error) {
+	if len(userIDs) == 0 {
+		return map[string]string{}, nil
+	}
+	users, err := s.UserCheck.GetPublicUserInfos(ctx, userIDs, complete)
+	if err != nil {
+		return nil, err
+	}
+	return utils.SliceToMapAny(users, func(e *sdkws.PublicUserInfo) (string, string) {
+		return e.UserID, e.Nickname
+	}), nil
+}
+
+func (s *groupServer) IsNotFound(err error) bool {
+	return utils.Unwrap(err) == gorm.ErrRecordNotFound
+}
+
+func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
+	if *groupID != "" {
+		_, err := s.GroupInterface.TakeGroup(ctx, *groupID)
+		if err == nil {
+			return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
+		} else if s.IsNotFound(err) {
+			return nil
+		} else {
+			return err
+		}
+	}
+	for i := 0; i < 10; i++ {
+		id := utils.Md5(strings.Join([]string{tracelog.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
+		bi := big.NewInt(0)
+		bi.SetString(id[0:8], 16)
+		id = bi.String()
+		_, err := s.GroupInterface.TakeGroup(ctx, id)
+		if err == nil {
+			continue
+		} else if s.IsNotFound(err) {
+			*groupID = id
+			return nil
+		} else {
+			return err
+		}
+	}
+	return constant.ErrData.Wrap("group id gen error")
+}
+
 func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
 	resp := &pbGroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
 	if err := tokenverify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
@@ -142,19 +129,18 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if utils.Duplicate(userIDs) {
 		return nil, constant.ErrArgs.Wrap("group member repeated")
 	}
-	userMap, err := GetUserInfoMap(ctx, userIDs)
+	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(userIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
-	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
+	if err := CallbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
 	var groupMembers []*relationTb.GroupMemberModel
 	group := PbToDBGroupInfo(req.GroupInfo)
-	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
+	if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
+		return nil, err
+	}
 	joinGroup := func(userID string, roleLevel int32) error {
 		groupMember := PbToDbGroupMember(userMap[userID])
 		groupMember.Nickname = ""
@@ -163,7 +149,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return err
 		}
 		groupMembers = append(groupMembers, groupMember)
@@ -196,11 +182,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if req.GroupInfo.GroupType == constant.SuperGroup {
 		go func() {
 			for _, userID := range userIDs {
-				chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+				s.Notification.SuperGroupNotification(ctx, userID, userID)
 			}
 		}()
 	} else {
-		chat.GroupCreatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), group.GroupID, userIDs)
+		s.Notification.GroupCreatedNotification(ctx, group.GroupID, userIDs)
 	}
 	return resp, nil
 }
@@ -269,13 +255,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
 		return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
 	}
-	userMap, err := GetUserInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(userMap)); len(ids) > 0 {
-		return nil, constant.ErrArgs.Wrap("user not found " + strings.Join(ids, ","))
-	}
 	if group.NeedVerification == constant.AllNeedVerification {
 		if !tokenverify.IsAppManagerUid(ctx) {
 			opUserID := tracelog.GetOpUserID(ctx)
@@ -297,7 +280,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 					return nil, err
 				}
 				for _, request := range requests {
-					chat.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
+					s.Notification.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
 						GroupID:       request.GroupID,
 						ReqMessage:    request.ReqMsg,
 						JoinSource:    request.JoinSource,
@@ -313,7 +296,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			return nil, err
 		}
 		for _, userID := range req.InvitedUserIDs {
-			chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+			s.Notification.SuperGroupNotification(ctx, userID, userID)
 		}
 	} else {
 		opUserID := tracelog.GetOpUserID(ctx)
@@ -326,7 +309,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			member.OperatorUserID = opUserID
 			member.InviterUserID = opUserID
 			member.JoinSource = constant.JoinByInvitation
-			if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+			if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 				return nil, err
 			}
 			groupMembers = append(groupMembers, member)
@@ -334,7 +317,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		if err := s.GroupInterface.CreateGroup(ctx, nil, groupMembers); err != nil {
 			return nil, err
 		}
-		chat.MemberInvitedNotification(tracelog.GetOperationID(ctx), req.GroupID, tracelog.GetOpUserID(ctx), req.Reason, req.InvitedUserIDs)
+		s.Notification.MemberInvitedNotification(ctx, req.GroupID, req.Reason, req.InvitedUserIDs)
 	}
 	return resp, nil
 }
@@ -352,9 +335,9 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -374,9 +357,9 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -411,7 +394,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		}
 		go func() {
 			for _, userID := range req.KickedUserIDs {
-				chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
+				s.Notification.SuperGroupNotification(ctx, userID, userID)
 			}
 		}()
 	} else {
@@ -451,7 +434,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		if err := s.GroupInterface.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
 			return nil, err
 		}
-		chat.MemberKickedNotification(req, req.KickedUserIDs)
+		s.Notification.MemberKickedNotification(ctx, req, req.KickedUserIDs)
 	}
 	return resp, nil
 }
@@ -468,9 +451,9 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -503,13 +486,10 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	}
 	userIDs = utils.Distinct(userIDs)
 	groupIDs = utils.Distinct(groupIDs)
-	userMap, err := GetPublicUserInfoMap(ctx, userIDs)
+	userMap, err := s.UserCheck.GetPublicUserInfoMap(ctx, userIDs, true)
 	if err != nil {
 		return nil, err
 	}
-	if ids := utils.Single(utils.Keys(userMap), userIDs); len(ids) > 0 {
-		return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
-	}
 	groups, err := s.GroupInterface.FindGroup(ctx, utils.Distinct(groupIDs))
 	if err != nil {
 		return nil, err
@@ -588,19 +568,18 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 	if groupRequest.HandleResult != 0 {
 		return nil, constant.ErrArgs.Wrap("group request already processed")
 	}
-	if _, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err != nil {
-		if !IsNotFound(err) {
-			return nil, err
-		}
-	} else {
-		return nil, constant.ErrArgs.Wrap("already in group")
+	var join bool
+	if _, err = s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
+		join = true // 已经在群里了
+	} else if !s.IsNotFound(err) {
+		return nil, err
 	}
-	user, err := GetPublicUserInfoOne(ctx, req.FromUserID)
+	user, err := s.UserCheck.GetPublicUserInfo(ctx, req.FromUserID)
 	if err != nil {
 		return nil, err
 	}
 	var member *relationTb.GroupMemberModel
-	if req.HandleResult == constant.GroupResponseAgree {
+	if (!join) && req.HandleResult == constant.GroupResponseAgree {
 		member = &relationTb.GroupMemberModel{
 			GroupID:        req.GroupID,
 			UserID:         user.UserID,
@@ -613,25 +592,27 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			OperatorUserID: tracelog.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
 		}
-		if err = CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, group.Ex); err != nil {
+		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil {
 			return nil, err
 		}
 	}
 	if err := s.GroupInterface.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
 		return nil, err
 	}
-	if req.HandleResult == constant.GroupResponseAgree {
-		chat.GroupApplicationAcceptedNotification(req)
-		chat.MemberEnterNotification(req)
-	} else if req.HandleResult == constant.GroupResponseRefuse {
-		chat.GroupApplicationRejectedNotification(req)
+	if !join {
+		if req.HandleResult == constant.GroupResponseAgree {
+			s.Notification.GroupApplicationAcceptedNotification(ctx, req)
+			s.Notification.MemberEnterNotification(ctx, req)
+		} else if req.HandleResult == constant.GroupResponseRefuse {
+			s.Notification.GroupApplicationRejectedNotification(ctx, req)
+		}
 	}
 	return resp, nil
 }
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
 	resp := &pbGroup.JoinGroupResp{}
-	if _, err := GetPublicUserInfoOne(ctx, tracelog.GetOpUserID(ctx)); err != nil {
+	if _, err := s.UserCheck.GetPublicUserInfo(ctx, tracelog.GetOpUserID(ctx)); err != nil {
 		return nil, err
 	}
 	group, err := s.GroupInterface.TakeGroup(ctx, req.GroupID)
@@ -655,13 +636,13 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
 		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
-		if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
+		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil {
 			return nil, err
 		}
 		if err := s.GroupInterface.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
 			return nil, err
 		}
-		chat.MemberEnterDirectlyNotification(req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
+		s.Notification.MemberEnterDirectlyNotification(ctx, req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
 		return resp, nil
 	}
 	groupRequest := relationTb.GroupRequestModel{
@@ -674,7 +655,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 	if err := s.GroupInterface.CreateGroupRequest(ctx, []*relationTb.GroupRequestModel{&groupRequest}); err != nil {
 		return nil, err
 	}
-	chat.JoinGroupApplicationNotification(ctx, req)
+	s.Notification.JoinGroupApplicationNotification(ctx, req)
 	return resp, nil
 }
 
@@ -688,13 +669,13 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		if err := s.GroupInterface.DeleteSuperGroupMember(ctx, req.GroupID, []string{tracelog.GetOpUserID(ctx)}); err != nil {
 			return nil, err
 		}
-		chat.SuperGroupNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
+		s.Notification.SuperGroupNotification(ctx, tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
 	} else {
 		_, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
-		chat.MemberQuitNotification(req)
+		s.Notification.MemberQuitNotification(ctx, req)
 	}
 	return resp, nil
 }
@@ -717,6 +698,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if group.Status == constant.GroupStatusDismissed {
 		return nil, utils.Wrap(constant.ErrDismissedAlready, "")
 	}
+	userIDs, err := s.GroupInterface.FindGroupMemberUserID(ctx, group.GroupID)
+	if err != nil {
+		return nil, err
+	}
 	data := UpdateGroupInfoMap(req.GroupInfoForSet)
 	if len(data) > 0 {
 		return resp, nil
@@ -728,9 +713,21 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if err != nil {
 		return nil, err
 	}
-	chat.GroupInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupInfoForSet.GroupID, group.GroupName, group.Notification, group.Introduction, group.FaceURL, req.GroupInfoForSet.NeedVerification)
+	s.Notification.GroupInfoSetNotification(ctx, req.GroupInfoForSet.GroupID, group.GroupName, group.Notification, group.Introduction, group.FaceURL, req.GroupInfoForSet.NeedVerification)
 	if req.GroupInfoForSet.Notification != "" {
-		GroupNotification(ctx, group.GroupID)
+		args := pbConversation.ModifyConversationFieldReq{
+			Conversation: &pbConversation.Conversation{
+				OwnerUserID:      tracelog.GetOpUserID(ctx),
+				ConversationID:   utils.GetConversationIDBySessionType(group.GroupID, constant.GroupChatType),
+				ConversationType: constant.GroupChatType,
+				GroupID:          group.GroupID,
+			},
+			FieldType:  constant.FieldGroupAtType,
+			UserIDList: userIDs,
+		}
+		if err := s.ConversationChecker.ModifyConversationField(ctx, &args); err != nil {
+			tracelog.SetCtxWarn(ctx, "ModifyConversationField", err, args)
+		}
 	}
 	return resp, nil
 }
@@ -778,7 +775,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 	if err := s.GroupInterface.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
 		return nil, err
 	}
-	chat.GroupOwnerTransferredNotification(req)
+	s.Notification.GroupOwnerTransferredNotification(ctx, req)
 	return resp, nil
 }
 
@@ -828,9 +825,9 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
 		return nil, err
 	}
 	resp.Total = total
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -845,7 +842,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{}
-	user, err := GetPublicUserInfoOne(ctx, req.UserID)
+	user, err := s.UserCheck.GetPublicUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -910,7 +907,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 			return nil, err
 		}
 	} else {
-		chat.GroupDismissedNotification(req)
+		s.Notification.GroupDismissedNotification(ctx, req)
 	}
 	return resp, nil
 }
@@ -934,7 +931,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 	if err := s.GroupInterface.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	chat.GroupMemberMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID, req.MutedSeconds)
+	s.Notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
 	return resp, nil
 }
 
@@ -957,7 +954,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 	if err := s.GroupInterface.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	chat.GroupMemberCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
+	s.Notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
 	return resp, nil
 }
 
@@ -969,7 +966,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 	if err := s.GroupInterface.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupStatusMuted)); err != nil {
 		return nil, err
 	}
-	chat.GroupMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
+	s.Notification.GroupMutedNotification(ctx, req.GroupID)
 	return resp, nil
 }
 
@@ -981,7 +978,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	if err := s.GroupInterface.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupOk)); err != nil {
 		return nil, err
 	}
-	chat.GroupCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
+	s.Notification.GroupCancelMutedNotification(ctx, req.GroupID)
 	return resp, nil
 }
 
@@ -1058,7 +1055,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		return nil, err
 	}
 	for _, member := range req.Members {
-		chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), member.GroupID, member.UserID)
+		s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
 	}
 	return resp, nil
 }
@@ -1103,9 +1100,9 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	nameMap, err := GetUsername(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
 		return e.UserID, e.Nickname == ""
-	}))
+	}), true)
 	if err != nil {
 		return nil, err
 	}
@@ -1127,3 +1124,27 @@ func (s *groupServer) GetGroupMemberUserID(ctx context.Context, req *pbGroup.Get
 	}
 	return resp, nil
 }
+
+func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
+	resp := &pbGroup.GetGroupMemberRoleLevelResp{}
+	if len(req.RoleLevels) == 0 {
+		return nil, constant.ErrArgs.Wrap("RoleLevels empty")
+	}
+	members, err := s.GroupInterface.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels)
+	if err != nil {
+		return nil, err
+	}
+	nameMap, err := s.GetUsernameMap(ctx, utils.Filter(members, func(e *relationTb.GroupMemberModel) (string, bool) {
+		return e.UserID, e.Nickname == ""
+	}), true)
+	if err != nil {
+		return nil, err
+	}
+	resp.Members = utils.Slice(members, func(e *relationTb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
+		if e.Nickname == "" {
+			e.Nickname = nameMap[e.UserID]
+		}
+		return DbToPbGroupMembersCMSResp(e)
+	})
+	return resp, nil
+}

internal/rpc/group/utils.go

@@ -1,13 +0,0 @@
-package group
-
-import (
-	"Open_IM/pkg/common/tracelog"
-	"gorm.io/gorm"
-)
-
-func IsNotFound(err error) bool {
-	if err == nil {
-		return false
-	}
-	return tracelog.Unwrap(err) == gorm.ErrRecordNotFound
-}

internal/rpc/msg/callback.go

@@ -1,23 +1,27 @@
 package msg
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
-	"Open_IM/pkg/common/callback"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	pbChat "Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/utils"
-	http2 "net/http"
+	"context"
 )
 
-func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq {
-	req := cbApi.CommonCallbackReq{
+func cbURL() string {
+	return config.Config.Callback.CallbackUrl
+}
+
+func toCommonCallback(ctx context.Context, msg *pbChat.SendMsgReq, command string) cbapi.CommonCallbackReq {
+	return cbapi.CommonCallbackReq{
 		SendID:           msg.MsgData.SendID,
 		ServerMsgID:      msg.MsgData.ServerMsgID,
+		CallbackCommand:  command,
 		ClientMsgID:      msg.MsgData.ClientMsgID,
-		OperationID:      msg.OperationID,
+		OperationID:      tracelog.GetOperationID(ctx),
 		SenderPlatformID: msg.MsgData.SenderPlatformID,
 		SenderNickname:   msg.MsgData.SenderNickname,
 		SessionType:      msg.MsgData.SessionType,
@@ -27,202 +31,90 @@ func copyCallbackCommonReqStruct(msg *pbChat.SendMsgReq) cbApi.CommonCallbackReq
 		CreateTime:       msg.MsgData.CreateTime,
 		AtUserIDList:     msg.MsgData.AtUserIDList,
 		SenderFaceURL:    msg.MsgData.SenderFaceURL,
-		Content:          callback.GetContent(msg.MsgData),
+		Content:          utils.GetContent(msg.MsgData),
 		Seq:              msg.MsgData.Seq,
 		Ex:               msg.MsgData.Ex,
 	}
-	return req
 }
 
-func callbackBeforeSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackBeforeSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackBeforeSendSingleMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendSingleMsgCommand
-	req := cbApi.CallbackBeforeSendSingleMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackBeforeSendSingleMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		RecvID:            msg.MsgData.RecvID,
 	}
-	resp := &cbApi.CallbackBeforeSendSingleMsgResp{
-		CommonCallbackResp: &callbackResp,
-	}
-	//utils.CopyStructFields(req, msg.MsgData)
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendSingleMsgCommand,
-		req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeSendSingleMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg)
 }
 
-func callbackAfterSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackAfterSendSingleMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackAfterSendSingleMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendSingleMsgCommand
-	req := cbApi.CallbackAfterSendSingleMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendSingleMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		RecvID:            msg.MsgData.RecvID,
 	}
-	resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendSingleMsgCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackAfterSendSingleMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		return callbackResp
-	}
-	return callbackResp
+	resp := &cbapi.CallbackAfterSendSingleMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
-func callbackBeforeSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
-	if !config.Config.Callback.CallbackBeforeSendGroupMsg.Enable {
-		return callbackResp
+func CallbackBeforeSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
+	if !config.Config.Callback.CallbackAfterSendSingleMsg.Enable {
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackBeforeSendGroupMsgCommand
-	req := cbApi.CallbackAfterSendGroupMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackBeforeSendSingleMsgCommand),
 		GroupID:           msg.MsgData.GroupID,
 	}
-	resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendGroupMsgCommand,
-		req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
-	}
-	return callbackResp
+	resp := &cbapi.CallbackBeforeSendGroupMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendSingleMsg)
 }
 
-func callbackAfterSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackAfterSendGroupMsg(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
-		return callbackResp
+		return nil
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackAfterSendGroupMsgCommand
-	req := cbApi.CallbackAfterSendGroupMsgReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackAfterSendGroupMsgReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackAfterSendGroupMsgCommand),
 		GroupID:           msg.MsgData.GroupID,
 	}
-	resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendGroupMsgCommand, req, resp,
-		config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		return callbackResp
-	}
-	return callbackResp
+	resp := &cbapi.CallbackAfterSendGroupMsgResp{}
+	return http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
-func callbackMsgModify(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), msg)
-	callbackResp := cbApi.CommonCallbackResp{OperationID: msg.OperationID}
+func CallbackMsgModify(ctx context.Context, msg *pbChat.SendMsgReq) error {
 	if !config.Config.Callback.CallbackMsgModify.Enable || msg.MsgData.ContentType != constant.Text {
-		return callbackResp
+		return nil
 	}
-	commonCallbackReq := copyCallbackCommonReqStruct(msg)
-	commonCallbackReq.CallbackCommand = constant.CallbackMsgModifyCommand
-	req := cbApi.CallbackMsgModifyCommandReq{
-		CommonCallbackReq: commonCallbackReq,
+	req := &cbapi.CallbackMsgModifyCommandReq{
+		CommonCallbackReq: toCommonCallback(ctx, msg, constant.CallbackMsgModifyCommand),
 	}
-	resp := &cbApi.CallbackMsgModifyCommandResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackMsgModifyCommand, req, resp,
-		config.Config.Callback.CallbackMsgModify.CallbackTimeOut, &config.Config.Callback.CallbackMsgModify.CallbackFailedContinue); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-		if !config.Config.Callback.CallbackMsgModify.CallbackFailedContinue {
-			callbackResp.ActionCode = constant.ActionForbidden
-			return callbackResp
-		} else {
-			callbackResp.ActionCode = constant.ActionAllow
-			return callbackResp
-		}
+	resp := &cbapi.CallbackMsgModifyCommandResp{}
+	if err := http.CallBackPostReturn(cbURL(), req, resp, config.Config.Callback.CallbackAfterSendGroupMsg); err != nil {
+		return err
 	}
-	if resp.ErrCode == constant.CallbackHandleSuccess && resp.ActionCode == constant.ActionAllow {
-		if resp.Content != nil {
-			msg.MsgData.Content = []byte(*resp.Content)
-		}
-		if resp.RecvID != nil {
-			msg.MsgData.RecvID = *resp.RecvID
-		}
-		if resp.GroupID != nil {
-			msg.MsgData.GroupID = *resp.GroupID
-		}
-		if resp.ClientMsgID != nil {
-			msg.MsgData.ClientMsgID = *resp.ClientMsgID
-		}
-		if resp.ServerMsgID != nil {
-			msg.MsgData.ServerMsgID = *resp.ServerMsgID
-		}
-		if resp.SenderPlatformID != nil {
-			msg.MsgData.SenderPlatformID = *resp.SenderPlatformID
-		}
-		if resp.SenderNickname != nil {
-			msg.MsgData.SenderNickname = *resp.SenderNickname
-		}
-		if resp.SenderFaceURL != nil {
-			msg.MsgData.SenderFaceURL = *resp.SenderFaceURL
-		}
-		if resp.SessionType != nil {
-			msg.MsgData.SessionType = *resp.SessionType
-		}
-		if resp.MsgFrom != nil {
-			msg.MsgData.MsgFrom = *resp.MsgFrom
-		}
-		if resp.ContentType != nil {
-			msg.MsgData.ContentType = *resp.ContentType
-		}
-		if resp.Status != nil {
-			msg.MsgData.Status = *resp.Status
-		}
-		if resp.Options != nil {
-			msg.MsgData.Options = *resp.Options
-		}
-		if resp.OfflinePushInfo != nil {
-			msg.MsgData.OfflinePushInfo = resp.OfflinePushInfo
-		}
-		if resp.AtUserIDList != nil {
-			msg.MsgData.AtUserIDList = *resp.AtUserIDList
-		}
-		if resp.MsgDataList != nil {
-			msg.MsgData.MsgDataList = *resp.MsgDataList
-		}
-		if resp.AttachedInfo != nil {
-			msg.MsgData.AttachedInfo = *resp.AttachedInfo
-		}
-		if resp.Ex != nil {
-			msg.MsgData.Ex = *resp.Ex
-		}
-
+	if resp.Content != nil {
+		msg.MsgData.Content = []byte(*resp.Content)
 	}
-	log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), string(msg.MsgData.Content))
-	return callbackResp
+	utils.NotNilReplace(msg.MsgData.OfflinePushInfo, resp.OfflinePushInfo)
+	utils.NotNilReplace(&msg.MsgData.RecvID, resp.RecvID)
+	utils.NotNilReplace(&msg.MsgData.GroupID, resp.GroupID)
+	utils.NotNilReplace(&msg.MsgData.ClientMsgID, resp.ClientMsgID)
+	utils.NotNilReplace(&msg.MsgData.ServerMsgID, resp.ServerMsgID)
+	utils.NotNilReplace(&msg.MsgData.SenderPlatformID, resp.SenderPlatformID)
+	utils.NotNilReplace(&msg.MsgData.SenderNickname, resp.SenderNickname)
+	utils.NotNilReplace(&msg.MsgData.SenderFaceURL, resp.SenderFaceURL)
+	utils.NotNilReplace(&msg.MsgData.SessionType, resp.SessionType)
+	utils.NotNilReplace(&msg.MsgData.MsgFrom, resp.MsgFrom)
+	utils.NotNilReplace(&msg.MsgData.ContentType, resp.ContentType)
+	utils.NotNilReplace(&msg.MsgData.Status, resp.Status)
+	utils.NotNilReplace(&msg.MsgData.Options, resp.Options)
+	utils.NotNilReplace(&msg.MsgData.AtUserIDList, resp.AtUserIDList)
+	utils.NotNilReplace(&msg.MsgData.MsgDataList, resp.MsgDataList)
+	utils.NotNilReplace(&msg.MsgData.AttachedInfo, resp.AttachedInfo)
+	utils.NotNilReplace(&msg.MsgData.Ex, resp.Ex)
+	return nil
 }

internal/rpc/msg/chat.go

@@ -1,63 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	pbChat "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-)
-
-func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbChat.ClearMsgResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
-	err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
-	err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
-	if err != nil {
-		errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-
-	resp := pbChat.ClearMsgResp{ErrCode: 0}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return &resp, nil
-}
-
-func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq) (*pbChat.SetMsgMinSeqResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc req: ", req.String())
-	if req.OpUserID != req.UserID && !tokenverify.IsManagerUserID(req.UserID) {
-		errMsg := "No permission" + req.OpUserID + req.UserID
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
-	}
-	if req.GroupID == "" {
-		err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq)
-		if err != nil {
-			errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq)
-			log.Error(req.OperationID, errMsg)
-			return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-		}
-		return &pbChat.SetMsgMinSeqResp{}, nil
-	}
-	err := db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, uint64(req.MinSeq))
-	if err != nil {
-		errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq)
-		log.Error(req.OperationID, errMsg)
-		return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
-	}
-	return &pbChat.SetMsgMinSeqResp{}, nil
-}

internal/rpc/msg/conversation_notification.go

@@ -1,84 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func SetConversationNotification(operationID, sendID, recvID string, contentType int, m proto.Message, tips sdkws.TipsComm) {
-	log.NewInfo(operationID, "args: ", sendID, recvID, contentType, m.String(), tips.String())
-	var err error
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.NewError(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvID
-	n.ContentType = int32(contentType)
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, utils.GetSelfFuncName(), "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}
-
-// SetPrivate调用
-func ConversationSetPrivateNotification(operationID, sendID, recvID string, isPrivateChat bool) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
-	conversationSetPrivateTips := &sdkws.ConversationSetPrivateTips{
-		RecvID:    recvID,
-		SendID:    sendID,
-		IsPrivate: isPrivateChat,
-	}
-	var tips sdkws.TipsComm
-	var tipsMsg string
-	if isPrivateChat == true {
-		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.OpenTips
-	} else {
-		tipsMsg = config.Config.Notification.ConversationSetPrivate.DefaultTips.CloseTips
-	}
-	tips.DefaultTips = tipsMsg
-	SetConversationNotification(operationID, sendID, recvID, constant.ConversationPrivateChatNotification, conversationSetPrivateTips, tips)
-}
-
-// 会话改变
-func ConversationChangeNotification(ctx context.Context, userID string) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
-	ConversationChangedTips := &sdkws.ConversationUpdateTips{
-		UserID: userID,
-	}
-	var tips sdkws.TipsComm
-	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	SetConversationNotification(operationID, userID, userID, constant.ConversationOptChangeNotification, ConversationChangedTips, tips)
-}
-
-//会话未读数同步
-func ConversationUnreadChangeNotification(operationID, userID, conversationID string, updateUnreadCountTime int64) {
-	log.NewInfo(operationID, utils.GetSelfFuncName())
-	ConversationChangedTips := &sdkws.ConversationUpdateTips{
-		UserID:                userID,
-		ConversationIDList:    []string{conversationID},
-		UpdateUnreadCountTime: updateUnreadCountTime,
-	}
-	var tips sdkws.TipsComm
-	tips.DefaultTips = config.Config.Notification.ConversationOptUpdate.DefaultTips.Tips
-	SetConversationNotification(operationID, userID, userID, constant.ConversationUnreadNotification, ConversationChangedTips, tips)
-}

internal/rpc/msg/del_msg.go

@@ -1,56 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	"Open_IM/pkg/proto/msg"
-	common "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"time"
-)
-
-func (rpc *rpcChat) DelMsgList(_ context.Context, req *common.DelMsgListReq) (*common.DelMsgListResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &common.DelMsgListResp{}
-	select {
-	case rpc.delMsgCh <- deleteMsg{
-		UserID:      req.UserID,
-		OpUserID:    req.OpUserID,
-		SeqList:     req.SeqList,
-		OperationID: req.OperationID,
-	}:
-	case <-time.After(1 * time.Second):
-		resp.ErrCode = constant.ErrSendLimit.ErrCode
-		resp.ErrMsg = constant.ErrSendLimit.ErrMsg
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}
-func (rpc *rpcChat) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	if !tokenverify.CheckAccess(ctx, req.OpUserID, req.UserID) {
-		log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserID)
-		return &msg.DelSuperGroupMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}, nil
-	}
-	resp := &msg.DelSuperGroupMsgResp{}
-	groupMaxSeq, err := db.DB.GetGroupMaxSeq(req.GroupID)
-	if err != nil {
-		log.NewError(req.OperationID, "GetGroupMaxSeq false ", req.OpUserID, req.UserID, req.GroupID)
-		resp.ErrCode = constant.ErrDB.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	err = db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, groupMaxSeq)
-	if err != nil {
-		log.NewError(req.OperationID, "SetGroupUserMinSeq false ", req.OpUserID, req.UserID, req.GroupID)
-		resp.ErrCode = constant.ErrDB.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
-	return resp, nil
-}

internal/rpc/msg/delete.go

@@ -0,0 +1,43 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/tokenverify"
+	"Open_IM/pkg/proto/msg"
+	common "Open_IM/pkg/proto/sdkws"
+	"context"
+)
+
+func (m *msgServer) DelMsgList(ctx context.Context, req *common.DelMsgListReq) (*common.DelMsgListResp, error) {
+	resp := &common.DelMsgListResp{}
+	if err := m.MsgInterface.DelMsgFromCache(ctx, req.UserID, req.SeqList); err != nil {
+		return nil, err
+	}
+	DeleteMessageNotification(ctx, req.UserID, req.SeqList)
+	return resp, nil
+}
+
+func (m *msgServer) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) {
+	resp := &msg.DelSuperGroupMsgResp{}
+	if err := tokenverify.CheckAdmin(ctx); err != nil {
+		return nil, err
+	}
+	maxSeq, err := m.MsgInterface.GetGroupMaxSeq(ctx, req.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	if err := m.MsgInterface.SetGroupUserMinSeq(ctx, req.GroupID, maxSeq); err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+func (m *msgServer) ClearMsg(ctx context.Context, req *msg.ClearMsgReq) (*msg.ClearMsgResp, error) {
+	resp := &msg.ClearMsgResp{}
+	if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	if err := m.MsgInterface.DelUserAllSeq(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	return resp, nil
+}

internal/rpc/msg/extend_msg.go

@@ -1,6 +1,7 @@
 package msg
 
 import (
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/log"
@@ -13,12 +14,12 @@ import (
 	"time"
 )
 
-func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.SetMessageReactionExtensionsReq) (resp *msg.SetMessageReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) SetMessageReactionExtensions(ctx context.Context, req *msg.SetMessageReactionExtensionsReq) (resp *msg.SetMessageReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.SetMessageReactionExtensionsResp
 	rResp.ClientMsgID = req.ClientMsgID
 	rResp.MsgFirstModifyTime = req.MsgFirstModifyTime
-	callbackResp := callbackSetMessageReactionExtensions(req)
+	callbackResp := notification.callbackSetMessageReactionExtensions(req)
 	if callbackResp.ActionCode != constant.ActionAllow || callbackResp.ErrCode != 0 {
 		rResp.ErrCode = int32(callbackResp.ErrCode)
 		rResp.ErrMsg = callbackResp.ErrMsg
@@ -41,7 +42,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 		}
 		rResp.MsgFirstModifyTime = callbackResp.MsgFirstModifyTime
 		rResp.Result = callbackResp.ResultReactionExtensionList
-		ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, isHistory, false)
+		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, isHistory, false)
 		return &rResp, nil
 	}
 	for _, v := range callbackResp.ResultReactionExtensionList {
@@ -71,7 +72,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 			log.Debug(req.OperationID, "redis handle firstly", req.String())
 			rResp.MsgFirstModifyTime = utils.GetCurrentTimestampByMill()
 			for k, v := range req.ReactionExtensionList {
-				err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
+				err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
 				if err != nil {
 					setKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, k, v)
 					continue
@@ -90,7 +91,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 				log.Error(req.OperationID, "SetMessageReactionExpire err:", err.Error(), req.String())
 			}
 		} else {
-			err := rpc.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
+			err := m.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
 			if err != nil {
 				rResp.ErrCode = 100
 				rResp.ErrMsg = err.Error()
@@ -148,7 +149,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 					rResp.Result = append(rResp.Result, temp)
 				}
 			}
-			lockErr := rpc.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
+			lockErr := m.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
 			if lockErr != nil {
 				log.Error(req.OperationID, "UnLockGlobalMessage err:", lockErr.Error())
 			}
@@ -158,7 +159,7 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 		log.Debug(req.OperationID, "redis handle secondly", req.String())
 
 		for k, v := range req.ReactionExtensionList {
-			err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
+			err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, k)
 			if err != nil {
 				setKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, k, v)
 				continue
@@ -187,14 +188,14 @@ func (rpc *rpcChat) SetMessageReactionExtensions(ctx context.Context, req *msg.S
 	}
 	if !isExists {
 		if !req.IsReact {
-			ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, true, true)
+			notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, true, true)
 		} else {
-			ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
+			notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
 		}
 	} else {
-		ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, true)
+		notification.ExtendMessageUpdatedNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, true)
 	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 
 }
@@ -215,8 +216,8 @@ func setDeleteKeyResultInfo(r *msg.DeleteMessageListReactionExtensionsResp, errC
 	_ = db.DB.UnLockMessageTypeKey(clientMsgID, typeKey)
 }
 
-func (rpc *rpcChat) GetMessageListReactionExtensions(ctx context.Context, req *msg.GetMessageListReactionExtensionsReq) (resp *msg.GetMessageListReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) GetMessageListReactionExtensions(ctx context.Context, req *msg.GetMessageListReactionExtensionsReq) (resp *msg.GetMessageListReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.GetMessageListReactionExtensionsResp
 	for _, messageValue := range req.MessageReactionKeyList {
 		var oneMessage msg.SingleMessageExtensionResult
@@ -266,19 +267,19 @@ func (rpc *rpcChat) GetMessageListReactionExtensions(ctx context.Context, req *m
 		}
 		rResp.SingleMessageResult = append(rResp.SingleMessageResult, &oneMessage)
 	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 
 }
 
-func (rpc *rpcChat) AddMessageReactionExtensions(ctx context.Context, req *msg.ModifyMessageReactionExtensionsReq) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
+func (m *msgServer) AddMessageReactionExtensions(ctx context.Context, req *msg.ModifyMessageReactionExtensionsReq) (resp *msg.ModifyMessageReactionExtensionsResp, err error) {
 	return
 }
 
-func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *msg.DeleteMessageListReactionExtensionsReq) (resp *msg.DeleteMessageListReactionExtensionsResp, err error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc args is:", req.String())
+func (m *msgServer) DeleteMessageReactionExtensions(ctx context.Context, req *msg.DeleteMessageListReactionExtensionsReq) (resp *msg.DeleteMessageListReactionExtensionsResp, err error) {
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m args is:", req.String())
 	var rResp msg.DeleteMessageListReactionExtensionsResp
-	callbackResp := callbackDeleteMessageReactionExtensions(req)
+	callbackResp := notification.callbackDeleteMessageReactionExtensions(req)
 	if callbackResp.ActionCode != constant.ActionAllow || callbackResp.ErrCode != 0 {
 		rResp.ErrCode = int32(callbackResp.ErrCode)
 		rResp.ErrMsg = callbackResp.ErrMsg
@@ -294,7 +295,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	//if ExternalExtension
 	if req.IsExternalExtensions {
 		rResp.Result = callbackResp.ResultReactionExtensionList
-		ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
+		notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, false)
 		return &rResp, nil
 
 	}
@@ -327,7 +328,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 	if isExists {
 		log.Debug(req.OperationID, "redis handle this delete", req.String())
 		for _, v := range req.ReactionExtensionList {
-			err := rpc.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, v.TypeKey)
+			err := m.dMessageLocker.LockMessageTypeKey(req.ClientMsgID, v.TypeKey)
 			if err != nil {
 				setDeleteKeyResultInfo(&rResp, 100, err.Error(), req.ClientMsgID, v.TypeKey, v)
 				continue
@@ -353,7 +354,7 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 			}
 		}
 	} else {
-		err := rpc.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
+		err := m.dMessageLocker.LockGlobalMessage(req.ClientMsgID)
 		if err != nil {
 			rResp.ErrCode = 100
 			rResp.ErrMsg = err.Error()
@@ -412,13 +413,13 @@ func (rpc *rpcChat) DeleteMessageReactionExtensions(ctx context.Context, req *ms
 				rResp.Result = append(rResp.Result, temp)
 			}
 		}
-		lockErr := rpc.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
+		lockErr := m.dMessageLocker.UnLockGlobalMessage(req.ClientMsgID)
 		if lockErr != nil {
 			log.Error(req.OperationID, "UnLockGlobalMessage err:", lockErr.Error())
 		}
 
 	}
-	ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, isExists)
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), "rpc return is:", rResp.String())
+	notification.ExtendMessageDeleteNotification(req.OperationID, req.OpUserID, req.SourceID, req.SessionType, req, &rResp, false, isExists)
+	log.Debug(req.OperationID, utils.GetSelfFuncName(), "m return is:", rResp.String())
 	return &rResp, nil
 }

internal/rpc/msg/extend_msg.notification.go

@@ -1,102 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/api_struct"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/getcdv3"
-	"Open_IM/pkg/proto/msg"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-)
-
-func ExtendMessageUpdatedNotification(operationID, sendID string, sourceID string, sessionType int32,
-	req *msg.SetMessageReactionExtensionsReq, resp *msg.SetMessageReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageModifierNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = req.OpUserID
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
-		return
-	}
-	m.SuccessReactionExtensionList = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.IsReact = resp.IsReact
-	m.IsExternalExtensions = req.IsExternalExtensions
-	m.MsgFirstModifyTime = resp.MsgFirstModifyTime
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageModifier, utils.StructToJsonString(m), isHistory, isReactionFromCache)
-}
-func ExtendMessageDeleteNotification(operationID, sendID string, sourceID string, sessionType int32,
-	req *msg.DeleteMessageListReactionExtensionsReq, resp *msg.DeleteMessageListReactionExtensionsResp, isHistory bool, isReactionFromCache bool) {
-	var m apistruct.ReactionMessageDeleteNotification
-	m.SourceID = req.SourceID
-	m.OpUserID = req.OpUserID
-	m.SessionType = req.SessionType
-	keyMap := make(map[string]*sdkws.KeyValue)
-	for _, valueResp := range resp.Result {
-		if valueResp.ErrCode == 0 {
-			keyMap[valueResp.KeyValue.TypeKey] = valueResp.KeyValue
-		}
-	}
-	if len(keyMap) == 0 {
-		log.NewWarn(operationID, "all key set failed can not send notification", *req)
-		return
-	}
-	m.SuccessReactionExtensionList = keyMap
-	m.ClientMsgID = req.ClientMsgID
-	m.MsgFirstModifyTime = req.MsgFirstModifyTime
-
-	messageReactionSender(operationID, sendID, sourceID, sessionType, constant.ReactionMessageDeleter, utils.StructToJsonString(m), isHistory, isReactionFromCache)
-}
-func messageReactionSender(operationID, sendID string, sourceID string, sessionType, contentType int32, content string, isHistory bool, isReactionFromCache bool) {
-	options := make(map[string]bool, 5)
-	utils.SetSwitchFromOptions(options, constant.IsOfflinePush, false)
-	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsSenderConversationUpdate, false)
-	utils.SetSwitchFromOptions(options, constant.IsUnreadCount, false)
-	utils.SetSwitchFromOptions(options, constant.IsReactionFromCache, isReactionFromCache)
-	if !isHistory {
-		utils.SetSwitchFromOptions(options, constant.IsHistory, false)
-		utils.SetSwitchFromOptions(options, constant.IsPersistent, false)
-	}
-	pbData := msg.SendMsgReq{
-		OperationID: operationID,
-		MsgData: &sdkws.MsgData{
-			SendID:      sendID,
-			ClientMsgID: utils.GetMsgID(sendID),
-			SessionType: sessionType,
-			MsgFrom:     constant.SysMsgType,
-			ContentType: contentType,
-			Content:     []byte(content),
-			//	ForceList:        params.ForceList,
-			CreateTime: utils.GetCurrentTimestampByMill(),
-			Options:    options,
-		},
-	}
-	switch sessionType {
-	case constant.SingleChatType, constant.NotificationChatType:
-		pbData.MsgData.RecvID = sourceID
-	case constant.GroupChatType, constant.SuperGroupChatType:
-		pbData.MsgData.GroupID = sourceID
-	}
-	etcdConn, err := rpc.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
-	if err != nil {
-		return
-	}
-	client := msg.NewMsgClient(etcdConn)
-	reply, err := client.SendMsg(context.Background(), &pbData)
-	if err != nil {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), err.Error())
-	} else if reply.ErrCode != 0 {
-		log.NewError(operationID, "SendMsg rpc failed, ", pbData.String(), reply.ErrCode, reply.ErrMsg)
-	}
-}

internal/rpc/msg/extend_msg_callback.go

@@ -1,21 +1,23 @@
 package msg
 
 import (
-	cbApi "Open_IM/pkg/callback_struct"
+	cbapi "Open_IM/pkg/callbackstruct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/proto/msg"
 	"Open_IM/pkg/utils"
-	http2 "net/http"
+	"context"
 )
 
-func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensionsReq) *cbApi.CallbackBeforeSetMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackBeforeSetMessageReactionExtReq{
-		OperationID:           setReq.OperationID,
+func CallbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMessageReactionExtensionsReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	req := &cbapi.CallbackBeforeSetMessageReactionExtReq{
+		OperationID:           tracelog.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackBeforeSetMessageReactionExtensionCommand,
 		SourceID:              setReq.SourceID,
 		OpUserID:              setReq.OpUserID,
@@ -26,21 +28,15 @@ func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensio
 		IsExternalExtensions:  setReq.IsExternalExtensions,
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
-	resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp}
-	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
-
+	resp := &cbapi.CallbackBeforeSetMessageReactionExtResp{}
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
 
-func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) *cbApi.CallbackDeleteMessageReactionExtResp {
-	callbackResp := cbApi.CommonCallbackResp{OperationID: setReq.OperationID}
-	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
-	req := cbApi.CallbackDeleteMessageReactionExtReq{
+func CallbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReactionExtensionsReq) error {
+	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+		return nil
+	}
+	req := &cbapi.CallbackDeleteMessageReactionExtReq{
 		OperationID:           setReq.OperationID,
 		CallbackCommand:       constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
 		SourceID:              setReq.SourceID,
@@ -51,12 +47,53 @@ func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReacti
 		IsExternalExtensions:  setReq.IsExternalExtensions,
 		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
 	}
-	resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp}
+	resp := &cbapi.CallbackDeleteMessageReactionExtResp{}
 	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
-	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
-		req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
-		callbackResp.ErrCode = http2.StatusInternalServerError
-		callbackResp.ErrMsg = err.Error()
-	}
-	return resp
+	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg)
 }
+
+//func CallbackGetMessageListReactionExtensions(getReq *msg.GetMessageListReactionExtensionsReq) error {
+//	if !config.Config.Callback.CallbackAfterSendGroupMsg.Enable {
+//		return nil
+//	}
+//	req := cbapi.CallbackGetMessageListReactionExtReq{
+//		OperationID:     getReq.OperationID,
+//		CallbackCommand: constant.CallbackGetMessageListReactionExtensionsCommand,
+//		SourceID:        getReq.SourceID,
+//		OpUserID:        getReq.OpUserID,
+//		SessionType:     getReq.SessionType,
+//		TypeKeyList:     getReq.TypeKeyList,
+//		MessageKeyList:  getReq.MessageReactionKeyList,
+//	}
+//	resp := &cbApi.CallbackGetMessageListReactionExtResp{CommonCallbackResp: &callbackResp}
+//	defer log.NewDebug(getReq.OperationID, utils.GetSelfFuncName(), req, *resp)
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackGetMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return resp
+//}
+//func callbackAddMessageReactionExtensions(setReq *msg.AddMessageReactionExtensionsReq) *cb.CallbackAddMessageReactionExtResp {
+//	callbackResp := cbapi.CommonCallbackResp{OperationID: setReq.OperationID}
+//	log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), setReq.String())
+//	req := cbapi.CallbackAddMessageReactionExtReq{
+//		OperationID:           setReq.OperationID,
+//		CallbackCommand:       constant.CallbackAddMessageListReactionExtensionsCommand,
+//		SourceID:              setReq.SourceID,
+//		OpUserID:              setReq.OpUserID,
+//		SessionType:           setReq.SessionType,
+//		ReactionExtensionList: setReq.ReactionExtensionList,
+//		ClientMsgID:           setReq.ClientMsgID,
+//		IsReact:               setReq.IsReact,
+//		IsExternalExtensions:  setReq.IsExternalExtensions,
+//		MsgFirstModifyTime:    setReq.MsgFirstModifyTime,
+//	}
+//	resp := &cbapi.CallbackAddMessageReactionExtResp{CommonCallbackResp: &callbackResp}
+//	defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp, *resp.CommonCallbackResp, resp.IsReact, resp.MsgFirstModifyTime)
+//	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAddMessageListReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil {
+//		callbackResp.ErrCode = http2.StatusInternalServerError
+//		callbackResp.ErrMsg = err.Error()
+//	}
+//	return resp
+//
+//}

internal/rpc/msg/friend_notification.go

@@ -1,173 +0,0 @@
-package msg
-
-import (
-	"Open_IM/internal/common/check"
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tracelog"
-	pbFriend "Open_IM/pkg/proto/friend"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func getFromToUserNickname(fromUserID, toUserID string) (string, string, error) {
-	users, err := check.GetUsersInfo(context.Background(), fromUserID, toUserID)
-	if err != nil {
-		return "", "", nil
-	}
-	if users[0].UserID == fromUserID {
-		return users[0].Nickname, users[1].Nickname, nil
-	}
-	return users[1].Nickname, users[0].Nickname, nil
-
-}
-
-func friendNotification(operationID, fromUserID, toUserID string, contentType int32, m proto.Message) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-
-	fromUserNickname, toUserNickname, err := getFromToUserNickname(fromUserID, toUserID)
-	if err != nil {
-		log.Error(operationID, "getFromToUserNickname failed ", err.Error(), fromUserID, toUserID)
-		return
-	}
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.FriendApplicationNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplication.DefaultTips.Tips
-	case constant.FriendApplicationApprovedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationApproved.DefaultTips.Tips
-	case constant.FriendApplicationRejectedNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendApplicationRejected.DefaultTips.Tips
-	case constant.FriendAddedNotification:
-		tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
-	case constant.FriendDeletedNotification:
-		tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
-	case constant.FriendRemarkSetNotification:
-		tips.DefaultTips = fromUserNickname + cn.FriendRemarkSet.DefaultTips.Tips
-	case constant.BlackAddedNotification:
-		tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips
-	case constant.BlackDeletedNotification:
-		tips.DefaultTips = cn.BlackDeleted.DefaultTips.Tips + toUserNickname
-	case constant.UserInfoUpdatedNotification:
-		tips.DefaultTips = cn.UserInfoUpdated.DefaultTips.Tips
-	case constant.FriendInfoUpdatedNotification:
-		tips.DefaultTips = cn.FriendInfoUpdated.DefaultTips.Tips + toUserNickname
-	default:
-		log.Error(operationID, "contentType failed ", contentType)
-		return
-	}
-
-	var n NotificationMsg
-	n.SendID = fromUserID
-	n.RecvID = toUserID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}
-
-func FriendApplicationAddNotification(ctx context.Context, req *pbFriend.AddFriendReq) {
-	FriendApplicationTips := sdkws.FriendApplicationTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
-}
-
-func FriendApplicationAgreedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
-}
-
-func FriendApplicationRefusedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
-	FriendApplicationApprovedTips := sdkws.FriendApplicationApprovedTips{FromToUserID: &sdkws.FromToUserID{}}
-	FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
-	FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
-	FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
-	friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
-}
-
-func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
-	friendAddedTips := sdkws.FriendAddedTips{Friend: &sdkws.FriendInfo{}, OpUser: &sdkws.PublicUserInfo{}}
-	user, err := check.GetUsersInfo(context.Background(), opUserID)
-	if err != nil {
-		return
-	}
-	friendAddedTips.OpUser.UserID = user[0].UserID
-	friendAddedTips.OpUser.Ex = user[0].Ex
-	friendAddedTips.OpUser.Nickname = user[0].Nickname
-	friendAddedTips.OpUser.FaceURL = user[0].FaceURL
-
-	friend, err := check.GetFriendsInfo(ctx, fromUserID, toUserID)
-	if err != nil {
-		return
-	}
-	friendAddedTips.Friend = friend
-	friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
-}
-
-func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
-	friendDeletedTips := sdkws.FriendDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
-	friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
-	friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
-}
-
-func FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
-	friendInfoChangedTips := sdkws.FriendInfoChangedTips{FromToUserID: &sdkws.FromToUserID{}}
-	friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
-	friendInfoChangedTips.FromToUserID.ToUserID = toUserID
-	friendNotification(tracelog.GetOperationID(ctx), fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
-}
-
-func BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) {
-	blackAddedTips := sdkws.BlackAddedTips{FromToUserID: &sdkws.FromToUserID{}}
-	blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID
-	blackAddedTips.FromToUserID.ToUserID = req.BlackUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
-}
-
-func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
-	blackDeletedTips := sdkws.BlackDeletedTips{FromToUserID: &sdkws.FromToUserID{}}
-	blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
-	blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
-	friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
-}
-
-// send to myself
-func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
-}
-
-func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
-	selfInfoUpdatedTips := sdkws.UserInfoUpdatedTips{UserID: changedUserID}
-	friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
-}

internal/rpc/msg/group_notification.go

@@ -1,621 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
-	"Open_IM/pkg/common/log"
-	"Open_IM/pkg/common/tokenverify"
-	utils2 "Open_IM/pkg/common/utils"
-	pbGroup "Open_IM/pkg/proto/group"
-	"Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"context"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-	"google.golang.org/protobuf/types/known/wrapperspb"
-)
-
-//message GroupCreatedTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo Creator = 2;
-//  repeated GroupMemberFullInfo MemberList = 3;
-//  uint64 OperationTime = 4;
-//} creator->group
-
-func setOpUserInfo(opUserID, groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	if tokenverify.IsManagerUserID(opUserID) {
-		u, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "GetUserByUserID failed")
-		}
-		utils.CopyStructFields(groupMemberInfo, u)
-		groupMemberInfo.GroupID = groupID
-	} else {
-		u, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, opUserID)
-		if err == nil {
-			if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, u); err != nil {
-				return utils.Wrap(err, "")
-			}
-		}
-		user, err := imdb.GetUserByUserID(opUserID)
-		if err != nil {
-			return utils.Wrap(err, "")
-		}
-		groupMemberInfo.GroupID = groupID
-		groupMemberInfo.UserID = user.UserID
-		groupMemberInfo.Nickname = user.Nickname
-		groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-		groupMemberInfo.FaceURL = user.FaceURL
-	}
-	return nil
-}
-
-func setGroupInfo(groupID string, groupInfo *sdkws.GroupInfo) error {
-	group, err := imdb.GetGroupInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "GetGroupInfoByGroupID failed")
-	}
-	err = utils2.GroupDBCopyOpenIM(groupInfo, group)
-	if err != nil {
-		log.NewWarn("", "GroupDBCopyOpenIM failed ", groupID, err.Error())
-		return nil
-	}
-	return nil
-}
-
-func setGroupMemberInfo(groupID, userID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
-	if err == nil {
-		return utils.Wrap(utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember), "")
-	}
-
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	groupMemberInfo.GroupID = groupID
-	groupMemberInfo.UserID = user.UserID
-	groupMemberInfo.Nickname = user.Nickname
-	groupMemberInfo.AppMangerLevel = user.AppMangerLevel
-	groupMemberInfo.FaceURL = user.FaceURL
-	return nil
-}
-
-func setGroupOwnerInfo(groupID string, groupMemberInfo *sdkws.GroupMemberFullInfo) error {
-	groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
-		return utils.Wrap(err, "")
-	}
-	return nil
-}
-
-func setPublicUserInfo(userID string, publicUserInfo *sdkws.PublicUserInfo) error {
-	user, err := imdb.GetUserByUserID(userID)
-	if err != nil {
-		return utils.Wrap(err, "")
-	}
-	utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
-	return nil
-}
-
-func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
-	log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType, sendID, groupID, recvUserID)
-
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var nickname string
-
-	from, err := imdb.GetUserByUserID(sendID)
-	if err != nil {
-		log.Error(operationID, "GetUserByUserID failed ", err.Error(), sendID)
-	}
-	if from != nil {
-		nickname = from.Nickname
-	}
-
-	to, err := imdb.GetUserByUserID(recvUserID)
-	if err != nil {
-		log.NewWarn(operationID, "GetUserByUserID failed ", err.Error(), recvUserID)
-	}
-	toNickname := ""
-	if to != nil {
-		toNickname = to.Nickname
-	}
-
-	cn := config.Config.Notification
-	switch contentType {
-	case constant.GroupCreatedNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupCreated.DefaultTips.Tips
-	case constant.GroupInfoSetNotification:
-		tips.DefaultTips = nickname + " " + cn.GroupInfoSet.DefaultTips.Tips
-	case constant.JoinGroupApplicationNotification:
-		tips.DefaultTips = nickname + " " + cn.JoinGroupApplication.DefaultTips.Tips
-	case constant.MemberQuitNotification:
-		tips.DefaultTips = nickname + " " + cn.MemberQuit.DefaultTips.Tips
-	case constant.GroupApplicationAcceptedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationAccepted.DefaultTips.Tips
-	case constant.GroupApplicationRejectedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupApplicationRejected.DefaultTips.Tips
-	case constant.GroupOwnerTransferredNotification: //
-		tips.DefaultTips = toNickname + " " + cn.GroupOwnerTransferred.DefaultTips.Tips
-	case constant.MemberKickedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberKicked.DefaultTips.Tips
-	case constant.MemberInvitedNotification: //
-		tips.DefaultTips = toNickname + " " + cn.MemberInvited.DefaultTips.Tips
-	case constant.MemberEnterNotification:
-		tips.DefaultTips = toNickname + " " + cn.MemberEnter.DefaultTips.Tips
-	case constant.GroupDismissedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupDismissed.DefaultTips.Tips
-	case constant.GroupMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMuted.DefaultTips.Tips
-	case constant.GroupCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
-	case constant.GroupMemberCancelMutedNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
-	case constant.GroupMemberInfoSetNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
-	case constant.GroupMemberSetToAdminNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToAdmin.DefaultTips.Tips
-	case constant.GroupMemberSetToOrdinaryUserNotification:
-		tips.DefaultTips = toNickname + "" + cn.GroupMemberSetToOrdinary.DefaultTips.Tips
-	default:
-		log.Error(operationID, "contentType failed ", contentType)
-		return
-	}
-
-	var n NotificationMsg
-	n.SendID = sendID
-	if groupID != "" {
-		n.RecvID = groupID
-		group, err := imdb.GetGroupInfoByGroupID(groupID)
-		if err != nil {
-			log.NewError(operationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID)
-		}
-		switch group.GroupType {
-		case constant.NormalGroup:
-			n.SessionType = constant.GroupChatType
-		default:
-			n.SessionType = constant.SuperGroupChatType
-		}
-	} else {
-		n.RecvID = recvUserID
-		n.SessionType = constant.SingleChatType
-	}
-	n.ContentType = contentType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}
-
-// 创建群后调用
-func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
-	GroupCreatedTips := sdkws.GroupCreatedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, GroupOwnerUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
-		log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
-		return
-	}
-	err := setGroupInfo(groupID, GroupCreatedTips.Group)
-	if err != nil {
-		log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
-		return
-	}
-	imdb.GetGroupOwnerInfoByGroupID(groupID)
-	if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
-		log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
-		return
-	}
-	for _, v := range initMemberList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
-			continue
-		}
-		GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
-		if len(GroupCreatedTips.MemberList) == constant.MaxNotificationNum {
-			break
-		}
-	}
-	groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
-}
-
-// 群信息改变后掉用
-// groupName := ""
-//
-//	notification := ""
-//	introduction := ""
-//	faceURL := ""
-func GroupInfoSetNotification(operationID, opUserID, groupID string, groupName, notification, introduction, faceURL string, needVerification *wrapperspb.Int32Value) {
-	GroupInfoChangedTips := sdkws.GroupInfoSetTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	GroupInfoChangedTips.Group.GroupName = groupName
-	GroupInfoChangedTips.Group.Notification = notification
-	GroupInfoChangedTips.Group.Introduction = introduction
-	GroupInfoChangedTips.Group.FaceURL = faceURL
-	if needVerification != nil {
-		GroupInfoChangedTips.Group.NeedVerification = needVerification.Value
-	}
-
-	if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
-}
-
-func GroupMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupCancelMutedNotification(operationID, opUserID, groupID string) {
-	tips := sdkws.GroupCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	groupNotification(constant.GroupCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUserID string, mutedSeconds uint32) {
-	tips := sdkws.GroupMemberMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	tips.MutedSeconds = mutedSeconds
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberRoleLevelChangeNotification(operationID, opUserID, groupID, groupMemberUserID string, notificationType int32) {
-	if notificationType != constant.GroupMemberSetToAdminNotification && notificationType != constant.GroupMemberSetToOrdinaryUserNotification {
-		log.NewError(operationID, utils.GetSelfFuncName(), "invalid notificationType: ", notificationType)
-		return
-	}
-	tips := sdkws.GroupMemberInfoSetTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, ChangedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(notificationType, &tips, opUserID, groupID, "", operationID)
-}
-
-func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
-	tips := sdkws.GroupMemberCancelMutedTips{Group: &sdkws.GroupInfo{},
-		OpUser: &sdkws.GroupMemberFullInfo{}, MutedUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, tips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.MutedUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
-		return
-	}
-	groupNotification(constant.GroupMemberCancelMutedNotification, &tips, opUserID, groupID, "", operationID)
-}
-
-//	message ReceiveJoinApplicationTips{
-//	 GroupInfo Group = 1;
-//	 PublicUserInfo Applicant  = 2;
-//	 string 	Reason = 3;
-//	}  apply->all managers GroupID              string   `protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"`
-//
-//	ReqMessage           string   `protobuf:"bytes,2,opt,name=ReqMessage" json:"ReqMessage,omitempty"`
-//	OpUserID             string   `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
-//	OperationID          string   `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
-//
-// 申请进群后调用
-func JoinGroupApplicationNotification(ctx context.Context, req *pbGroup.JoinGroupReq) {
-	JoinGroupApplicationTips := sdkws.JoinGroupApplicationTips{Group: &sdkws.GroupInfo{}, Applicant: &sdkws.PublicUserInfo{}}
-	err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
-	if err != nil {
-		log.Error(utils.OperationID(ctx), "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err = setPublicUserInfo(utils.OpUserID(ctx), JoinGroupApplicationTips.Applicant); err != nil {
-		log.Error(utils.OperationID(ctx), "setPublicUserInfo failed ", err.Error(), utils.OpUserID(ctx))
-		return
-	}
-	JoinGroupApplicationTips.ReqMsg = req.ReqMessage
-
-	managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.NewError(utils.OperationID(ctx), "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
-		return
-	}
-	for _, v := range managerList {
-		groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, utils.OpUserID(ctx), "", v.UserID, utils.OperationID(ctx))
-		log.NewInfo(utils.OperationID(ctx), "Notification ", v)
-	}
-}
-
-func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
-	MemberQuitTips := sdkws.MemberQuitTips{Group: &sdkws.GroupInfo{}, QuitUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
-		return
-	}
-
-	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message ApplicationProcessedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 int32 Result = 3;
-//	 string 	Reason = 4;
-//	}
-//
-// 处理进群请求后调用
-func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationAcceptedTips := sdkws.GroupApplicationAcceptedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
-		return
-	}
-
-	groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationAcceptedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
-	GroupApplicationRejectedTips := sdkws.GroupApplicationRejectedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
-	if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
-		return
-	}
-	groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
-	adminList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
-	if err != nil {
-		log.Error(req.OperationID, "GetOwnerManagerByGroupID failed", req.GroupID)
-		return
-	}
-	for _, v := range adminList {
-		if v.UserID == req.OpUserID {
-			continue
-		}
-		GroupApplicationRejectedTips.ReceiverAs = 1
-		groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", v.UserID, req.OperationID)
-	}
-}
-
-func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
-	GroupOwnerTransferredTips := sdkws.GroupOwnerTransferredTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}, NewGroupOwner: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
-		return
-	}
-	groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func GroupDismissedNotification(req *pbGroup.DismissGroupReq) {
-	tips := sdkws.GroupDismissedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, tips.Group); err != nil {
-		log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, tips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
-		return
-	}
-	groupNotification(constant.GroupDismissedNotification, &tips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-//	message MemberKickedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo KickedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被踢后调用
-func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
-	MemberKickedTips := sdkws.MemberKickedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
-		return
-	}
-	if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
-		log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
-		return
-	}
-	for _, v := range kickedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(req.GroupID, v, &groupMemberInfo); err != nil {
-			log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.GroupID, v)
-			continue
-		}
-		MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
-	//
-	//for _, v := range kickedUserIDList {
-	//	groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
-	//}
-}
-
-//	message MemberInvitedTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo OpUser = 2;
-//	 GroupMemberFullInfo InvitedUser = 3;
-//	 uint64 OperationTime = 4;
-//	}
-//
-// 被邀请进群后调用
-func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
-	MemberInvitedTips := sdkws.MemberInvitedTips{Group: &sdkws.GroupInfo{}, OpUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
-		return
-	}
-	if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
-		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
-		return
-	}
-	for _, v := range invitedUserIDList {
-		var groupMemberInfo sdkws.GroupMemberFullInfo
-		if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
-			log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
-			continue
-		}
-		MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
-	}
-	groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
-}
-
-//message GroupInfoChangedTips{
-//  int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification  100:Introduction; 1000:FaceUrl
-//  GroupInfo Group = 2;
-//  GroupMemberFullInfo OpUser = 3;
-//}
-
-//message MemberLeaveTips{
-//  GroupInfo Group = 1;
-//  GroupMemberFullInfo LeaverUser = 2;
-//  uint64 OperationTime = 3;
-//}
-
-//群成员退群后调用
-
-//	message MemberEnterTips{
-//	 GroupInfo Group = 1;
-//	 GroupMemberFullInfo EntrantUser = 2;
-//	 uint64 OperationTime = 3;
-//	}
-//
-// 群成员主动申请进群，管理员同意后调用，
-func MemberEnterNotification(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
-		log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(req.GroupID, req.FromUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(req.OperationID, "setGroupMemberInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
-}
-
-func MemberEnterDirectlyNotification(groupID string, entrantUserID string, operationID string) {
-	MemberEnterTips := sdkws.MemberEnterTips{Group: &sdkws.GroupInfo{}, EntrantUser: &sdkws.GroupMemberFullInfo{}}
-	if err := setGroupInfo(groupID, MemberEnterTips.Group); err != nil {
-		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, MemberEnterTips.Group)
-		return
-	}
-	if err := setGroupMemberInfo(groupID, entrantUserID, MemberEnterTips.EntrantUser); err != nil {
-		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, entrantUserID, MemberEnterTips.EntrantUser)
-		return
-	}
-	groupNotification(constant.MemberEnterNotification, &MemberEnterTips, entrantUserID, groupID, "", operationID)
-}

internal/rpc/msg/msg_notification.go

@@ -1,47 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"
-)
-
-func DeleteMessageNotification(opUserID, userID string, seqList []uint32, operationID string) {
-	DeleteMessageTips := sdkws.DeleteMessageTips{OpUserID: opUserID, UserID: userID, SeqList: seqList}
-	MessageNotification(operationID, userID, userID, constant.DeleteMessageNotification, &DeleteMessageTips)
-}
-
-func MessageNotification(operationID, sendID, recvID string, contentType int32, m proto.Message) {
-	log.Debug(operationID, utils.GetSelfFuncName(), "args: ", m.String(), contentType)
-	var err error
-	var tips sdkws.TipsComm
-	tips.Detail, err = proto.Marshal(m)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), m.String())
-		return
-	}
-
-	marshaler := jsonpb.Marshaler{
-		OrigName:     true,
-		EnumsAsInts:  false,
-		EmitDefaults: false,
-	}
-
-	tips.JsonDetail, _ = marshaler.MarshalToString(m)
-	var n NotificationMsg
-	n.SendID = sendID
-	n.RecvID = recvID
-	n.ContentType = contentType
-	n.SessionType = constant.SingleChatType
-	n.MsgFrom = constant.SysMsgType
-	n.OperationID = operationID
-	n.Content, err = proto.Marshal(&tips)
-	if err != nil {
-		log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
-		return
-	}
-	Notification(&n)
-}

internal/rpc/msg/msg_status.go

@@ -2,45 +2,28 @@ package msg
 
 import (
 	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/tracelog"
 	pbMsg "Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
 	"context"
-
-	goRedis "github.com/go-redis/redis/v8"
 )
 
-func (rpc *rpcChat) SetSendMsgStatus(_ context.Context, req *pbMsg.SetSendMsgStatusReq) (resp *pbMsg.SetSendMsgStatusResp, err error) {
-	resp = &pbMsg.SetSendMsgStatusResp{}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
-	if err := db.DB.SetSendMsgStatus(req.Status, req.OperationID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		resp.ErrCode = constant.ErrDatabase.ErrCode
-		resp.ErrMsg = err.Error()
-		return resp, nil
+func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgStatusReq) (*pbMsg.SetSendMsgStatusResp, error) {
+	resp := &pbMsg.SetSendMsgStatusResp{}
+	if err := m.MsgInterface.SetSendMsgStatus(ctx, tracelog.GetOperationID(ctx), req.Status); err != nil {
+		return nil, err
 	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
 	return resp, nil
 }
 
-func (rpc *rpcChat) GetSendMsgStatus(_ context.Context, req *pbMsg.GetSendMsgStatusReq) (resp *pbMsg.GetSendMsgStatusResp, err error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
-	resp = &pbMsg.GetSendMsgStatusResp{}
-	status, err := db.DB.GetSendMsgStatus(req.OperationID)
-	if err != nil {
+func (m *msgServer) GetSendMsgStatus(ctx context.Context, req *pbMsg.GetSendMsgStatusReq) (*pbMsg.GetSendMsgStatusResp, error) {
+	resp := &pbMsg.GetSendMsgStatusResp{}
+	status, err := m.MsgInterface.GetSendMsgStatus(ctx, tracelog.GetOperationID(ctx))
+	if IsNotFound(err) {
 		resp.Status = constant.MsgStatusNotExist
-		if err == goRedis.Nil {
-			log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.OperationID, "not exist")
-			return resp, nil
-		} else {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-			resp.ErrMsg = err.Error()
-			resp.ErrCode = constant.ErrDB.ErrCode
-			return resp, nil
-		}
+		return resp, nil
+	} else if err != nil {
+		return nil, err
 	}
-	resp.Status = int32(status)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
+	resp.Status = status
 	return resp, nil
 }

internal/rpc/msg/notification.go

@@ -0,0 +1,7 @@
+package msg
+
+import "context"
+
+func DeleteMessageNotification(ctx context.Context, userID string, seqs []uint32) {
+	panic("todo")
+}

internal/rpc/msg/pull_message.go

@@ -1,126 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/utils"
-	"context"
-	go_redis "github.com/go-redis/redis/v8"
-
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	sdkws "Open_IM/pkg/proto/sdkws"
-
-	prome "Open_IM/pkg/common/prometheus"
-)
-
-func (rpc *rpcChat) GetMaxAndMinSeq(_ context.Context, in *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
-	log.NewInfo(in.OperationID, "rpc getMaxAndMinSeq is arriving", in.String())
-	resp := new(sdkws.GetMaxAndMinSeqResp)
-	m := make(map[string]*sdkws.MaxAndMinSeq)
-	var maxSeq, minSeq uint64
-	var err1, err2 error
-	maxSeq, err1 = commonDB.DB.GetUserMaxSeq(in.UserID)
-	minSeq, err2 = commonDB.DB.GetUserMinSeq(in.UserID)
-	if (err1 != nil && err1 != go_redis.Nil) || (err2 != nil && err2 != go_redis.Nil) {
-		log.NewError(in.OperationID, "getMaxSeq from redis error", in.String())
-		if err1 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err1.Error())
-		}
-		if err2 != nil {
-			log.NewError(in.OperationID, utils.GetSelfFuncName(), err2.Error())
-		}
-		resp.ErrCode = 200
-		resp.ErrMsg = "redis get err"
-		return resp, nil
-	}
-	resp.MaxSeq = uint32(maxSeq)
-	resp.MinSeq = uint32(minSeq)
-	for _, groupID := range in.GroupIDList {
-		x := new(sdkws.MaxAndMinSeq)
-		maxSeq, _ := commonDB.DB.GetGroupMaxSeq(groupID)
-		minSeq, _ := commonDB.DB.GetGroupUserMinSeq(groupID, in.UserID)
-		x.MaxSeq = uint32(maxSeq)
-		x.MinSeq = uint32(minSeq)
-		m[groupID] = x
-	}
-	resp.GroupMaxAndMinSeq = m
-	return resp, nil
-}
-
-func (rpc *rpcChat) PullMessageBySeqList(_ context.Context, in *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
-	log.NewInfo(in.OperationID, "rpc PullMessageBySeqList is arriving", in.String())
-	resp := new(sdkws.PullMessageBySeqListResp)
-	m := make(map[string]*sdkws.MsgDataList)
-	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(in.UserID, in.SeqList, in.OperationID)
-	if err != nil {
-		if err != go_redis.Nil {
-			prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-		} else {
-			log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-		}
-		msgList, err1 := commonDB.DB.GetMsgBySeqs(in.UserID, failedSeqList, in.OperationID)
-		if err1 != nil {
-			prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-			log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-			resp.ErrCode = 201
-			resp.ErrMsg = err1.Error()
-			return resp, nil
-		} else {
-			prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-			redisMsgList = append(redisMsgList, msgList...)
-			resp.List = redisMsgList
-		}
-	} else {
-		prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-		resp.List = redisMsgList
-	}
-
-	for k, v := range in.GroupSeqList {
-		x := new(sdkws.MsgDataList)
-		redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(k, v.SeqList, in.OperationID)
-		if err != nil {
-			if err != go_redis.Nil {
-				prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-			} else {
-				log.Debug(in.OperationID, "get message from redis is nil", failedSeqList)
-			}
-			msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqs(k, failedSeqList, in.OperationID)
-			if err1 != nil {
-				prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-				log.Error(in.OperationID, "PullMessageBySeqList data error", in.String(), err1.Error())
-				resp.ErrCode = 201
-				resp.ErrMsg = err1.Error()
-				return resp, nil
-			} else {
-				prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-				redisMsgList = append(redisMsgList, msgList...)
-				x.MsgDataList = redisMsgList
-				m[k] = x
-			}
-		} else {
-			prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-			x.MsgDataList = redisMsgList
-			m[k] = x
-		}
-	}
-	resp.GroupMsgDataList = m
-	return resp, nil
-}
-
-type MsgFormats []*sdkws.MsgData
-
-// Implement the sort.Interface interface to get the number of elements method
-func (s MsgFormats) Len() int {
-	return len(s)
-}
-
-//Implement the sort.Interface interface comparison element method
-func (s MsgFormats) Less(i, j int) bool {
-	return s[i].SendTime < s[j].SendTime
-}
-
-//Implement the sort.Interface interface exchange element method
-func (s MsgFormats) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
-}

internal/rpc/msg/query_msg.go

@@ -1,51 +0,0 @@
-package msg
-
-import (
-	commonDB "Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
-	"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"context"
-	go_redis "github.com/go-redis/redis/v8"
-)
-
-func (rpc *rpcChat) GetSuperGroupMsg(context context.Context, req *msg.GetSuperGroupMsgReq) (*msg.GetSuperGroupMsgResp, error) {
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), req.String())
-	resp := new(msg.GetSuperGroupMsgResp)
-	redisMsgList, failedSeqList, err := commonDB.DB.GetMessageListBySeq(req.GroupID, []uint32{req.Seq}, req.OperationID)
-	if err != nil {
-		if err != go_redis.Nil {
-			prome.PromeAdd(prome.MsgPullFromRedisFailedCounter, len(failedSeqList))
-			log.Error(req.OperationID, "get message from redis exception", err.Error(), failedSeqList)
-		} else {
-			log.Debug(req.OperationID, "get message from redis is nil", failedSeqList)
-		}
-		msgList, err1 := commonDB.DB.GetSuperGroupMsgBySeqs(req.GroupID, failedSeqList, req.OperationID)
-		if err1 != nil {
-			prome.PromeAdd(prome.MsgPullFromMongoFailedCounter, len(failedSeqList))
-			log.Error(req.OperationID, "GetSuperGroupMsg data error", req.String(), err.Error())
-			resp.ErrCode = 201
-			resp.ErrMsg = err.Error()
-			return resp, nil
-		} else {
-			prome.PromeAdd(prome.MsgPullFromMongoSuccessCounter, len(msgList))
-			redisMsgList = append(redisMsgList, msgList...)
-			for _, m := range msgList {
-				resp.MsgData = m
-			}
-
-		}
-	} else {
-		prome.PromeAdd(prome.MsgPullFromRedisSuccessCounter, len(redisMsgList))
-		for _, m := range redisMsgList {
-			resp.MsgData = m
-		}
-	}
-	log.Debug(req.OperationID, utils.GetSelfFuncName(), resp.String())
-	return resp, nil
-}
-
-func (rpc *rpcChat) GetWriteDiffMsg(context context.Context, req *msg.GetWriteDiffMsgReq) (*msg.GetWriteDiffMsgResp, error) {
-	panic("implement me")
-}

internal/rpc/msg/rpc_chat.go

@@ -1,159 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/db"
-	"Open_IM/pkg/common/kafka"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
-	"Open_IM/pkg/proto/msg"
-	"Open_IM/pkg/utils"
-	"github.com/OpenIMSDK/getcdv3"
-	"net"
-	"strconv"
-	"strings"
-
-	"github.com/golang/protobuf/proto"
-
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
-	"google.golang.org/grpc"
-)
-
-type MessageWriter interface {
-	SendMessage(m proto.Message, key string, operationID string) (int32, int64, error)
-}
-type rpcChat struct {
-	rpcPort         int
-	rpcRegisterName string
-	etcdSchema      string
-	etcdAddr        []string
-	messageWriter   MessageWriter
-	//offlineProducer *kafka.Producer
-	delMsgCh       chan deleteMsg
-	dMessageLocker MessageLocker
-}
-
-type deleteMsg struct {
-	UserID      string
-	OpUserID    string
-	SeqList     []uint32
-	OperationID string
-}
-
-func NewRpcChatServer(port int) *rpcChat {
-	log.NewPrivateLog(constant.LogFileName)
-	rc := rpcChat{
-		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImMsgName,
-		etcdSchema:      config.Config.Etcd.EtcdSchema,
-		etcdAddr:        config.Config.Etcd.EtcdAddr,
-		dMessageLocker:  NewLockerMessage(),
-	}
-	rc.messageWriter = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschat.Addr, config.Config.Kafka.Ws2mschat.Topic)
-	//rc.offlineProducer = kafka.NewKafkaProducer(config.Config.Kafka.Ws2mschatOffline.Addr, config.Config.Kafka.Ws2mschatOffline.Topic)
-	rc.delMsgCh = make(chan deleteMsg, 1000)
-	return &rc
-}
-
-func (rpc *rpcChat) initPrometheus() {
-	//sendMsgSuccessCounter = promauto.NewCounter(prometheus.CounterOpts{
-	//	Name: "send_msg_success",
-	//	Help: "The number of send msg success",
-	//})
-	//sendMsgFailedCounter = promauto.NewCounter(prometheus.CounterOpts{
-	//	Name: "send_msg_failed",
-	//	Help: "The number of send msg failed",
-	//})
-	prome.NewMsgPullFromRedisSuccessCounter()
-	prome.NewMsgPullFromRedisFailedCounter()
-	prome.NewMsgPullFromMongoSuccessCounter()
-	prome.NewMsgPullFromMongoFailedCounter()
-
-	prome.NewSingleChatMsgRecvSuccessCounter()
-	prome.NewGroupChatMsgRecvSuccessCounter()
-	prome.NewWorkSuperGroupChatMsgRecvSuccessCounter()
-
-	prome.NewSingleChatMsgProcessSuccessCounter()
-	prome.NewSingleChatMsgProcessFailedCounter()
-	prome.NewGroupChatMsgProcessSuccessCounter()
-	prome.NewGroupChatMsgProcessFailedCounter()
-	prome.NewWorkSuperGroupChatMsgProcessSuccessCounter()
-	prome.NewWorkSuperGroupChatMsgProcessFailedCounter()
-}
-
-func (rpc *rpcChat) Run() {
-	log.Info("", "rpcChat init...")
-	listenIP := ""
-	if config.Config.ListenIP == "" {
-		listenIP = "0.0.0.0"
-	} else {
-		listenIP = config.Config.ListenIP
-	}
-	address := listenIP + ":" + strconv.Itoa(rpc.rpcPort)
-	listener, err := net.Listen("tcp", address)
-	if err != nil {
-		panic("listening err:" + err.Error() + rpc.rpcRegisterName)
-	}
-	log.Info("", "listen network success, address ", address)
-	recvSize := 1024 * 1024 * 30
-	sendSize := 1024 * 1024 * 30
-	var grpcOpts = []grpc.ServerOption{
-		grpc.MaxRecvMsgSize(recvSize),
-		grpc.MaxSendMsgSize(sendSize),
-	}
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-
-	rpcRegisterIP := config.Config.RpcRegisterIP
-	msg.RegisterMsgServer(srv, rpc)
-	if config.Config.RpcRegisterIP == "" {
-		rpcRegisterIP, err = utils.GetLocalIP()
-		if err != nil {
-			log.Error("", "GetLocalIP failed ", err.Error())
-		}
-	}
-	err = getcdv3.RegisterEtcd(rpc.etcdSchema, strings.Join(rpc.etcdAddr, ","), rpcRegisterIP, rpc.rpcPort, rpc.rpcRegisterName, 10, "")
-	if err != nil {
-		log.Error("", "register rpcChat to etcd failed ", err.Error())
-		panic(utils.Wrap(err, "register chat module  rpc to etcd err"))
-	}
-	go rpc.runCh()
-	rpc.initPrometheus()
-	err = srv.Serve(listener)
-	if err != nil {
-		log.Error("", "rpc rpcChat failed ", err.Error())
-		return
-	}
-	log.Info("", "rpc rpcChat init success")
-}
-
-func (rpc *rpcChat) runCh() {
-	log.NewInfo("", "start del msg chan ")
-	for {
-		select {
-		case msg := <-rpc.delMsgCh:
-			log.NewInfo(msg.OperationID, utils.GetSelfFuncName(), "delmsgch recv new: ", msg)
-			db.DB.DelMsgFromCache(msg.UserID, msg.SeqList, msg.OperationID)
-			unexistSeqList, err := db.DB.DelMsgBySeqs(msg.UserID, msg.SeqList, msg.OperationID)
-			if err != nil {
-				log.NewError(msg.OperationID, utils.GetSelfFuncName(), "DelMsgBySeqs args: ", msg.UserID, msg.SeqList, msg.OperationID, err.Error())
-				continue
-			}
-			if len(unexistSeqList) > 0 {
-				DeleteMessageNotification(msg.OpUserID, msg.UserID, unexistSeqList, msg.OperationID)
-			}
-		}
-	}
-}

internal/rpc/msg/send_pull.go

@@ -0,0 +1,304 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/constant"
+	promePkg "Open_IM/pkg/common/prometheus"
+	pbConversation "Open_IM/pkg/proto/conversation"
+	"Open_IM/pkg/proto/msg"
+	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/golang/protobuf/proto"
+	"sync"
+)
+
+func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
+	// callback
+	if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil {
+		return nil, err
+	}
+
+	if _, err = m.messageVerification(ctx, req); err != nil {
+		promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
+		return nil, err
+	}
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.GroupID, &msgToMQSingle)
+	if err != nil {
+		return nil, err
+	}
+	// callback
+	if err = CallbackAfterSendGroupMsg(ctx, req); err != nil {
+		return nil, err
+	}
+
+	promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.RecvID, &msgToMQSingle)
+	if err != nil {
+		return nil, err
+	}
+	if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+		err = m.MsgInterface.MsgToMQ(ctx, msgToMQSingle.MsgData.SendID, &msgToMQSingle)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	promePkg.PromeInc(promePkg.SingleChatMsgRecvSuccessCounter)
+	if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil {
+		return nil, err
+	}
+	_, err = m.messageVerification(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	isSend, err := modifyMessageByUserMessageReceiveOpt(req.MsgData.RecvID, req.MsgData.SendID, constant.SingleChatType, req)
+	if err != nil {
+		return nil, err
+	}
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	if isSend {
+		err = m.MsgInterface.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle)
+		if err != nil {
+			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+		}
+	}
+	if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
+		err = m.MsgInterface.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle)
+		if err != nil {
+			return nil, constant.ErrInternalServer.Wrap("insert to mq")
+		}
+	}
+	err = CallbackAfterSendSingleMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	promePkg.PromeInc(promePkg.SingleChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
+	// callback
+	promePkg.PromeInc(promePkg.GroupChatMsgRecvSuccessCounter)
+	err = CallbackBeforeSendGroupMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var memberUserIDList []string
+	if memberUserIDList, err = m.messageVerification(ctx, req); err != nil {
+		promePkg.PromeInc(promePkg.GroupChatMsgProcessFailedCounter)
+		return nil, err
+	}
+
+	var addUidList []string
+	switch req.MsgData.ContentType {
+	case constant.MemberKickedNotification:
+		var tips sdkws.TipsComm
+		var memberKickedTips sdkws.MemberKickedTips
+		err := proto.Unmarshal(req.MsgData.Content, &tips)
+		if err != nil {
+			return nil, err
+		}
+		err = proto.Unmarshal(tips.Detail, &memberKickedTips)
+		if err != nil {
+			return nil, err
+		}
+		for _, v := range memberKickedTips.KickedUserList {
+			addUidList = append(addUidList, v.UserID)
+		}
+	case constant.MemberQuitNotification:
+		addUidList = append(addUidList, req.MsgData.SendID)
+
+	default:
+	}
+	if len(addUidList) > 0 {
+		memberUserIDList = append(memberUserIDList, addUidList...)
+	}
+
+	//split  parallel send
+	var wg sync.WaitGroup
+	var split = 20
+	msgToMQSingle := msg.MsgDataToMQ{MsgData: req.MsgData}
+	mErr := make([]error, 0)
+	var mutex sync.RWMutex
+	remain := len(memberUserIDList) % split
+	for i := 0; i < len(memberUserIDList)/split; i++ {
+		wg.Add(1)
+		tmp := valueCopy(req)
+		go func() {
+			err := m.sendMsgToGroupOptimization(ctx, memberUserIDList[i*split:(i+1)*split], tmp, &wg)
+			if err != nil {
+				mutex.Lock()
+				mErr = append(mErr, err)
+				mutex.Unlock()
+			}
+
+		}()
+	}
+	if remain > 0 {
+		wg.Add(1)
+		tmp := valueCopy(req)
+		go m.sendMsgToGroupOptimization(ctx, memberUserIDList[split*(len(memberUserIDList)/split):], tmp, &wg)
+	}
+
+	wg.Wait()
+
+	// callback
+	err = CallbackAfterSendGroupMsg(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, v := range mErr {
+		if v != nil {
+			return nil, v
+		}
+	}
+
+	if req.MsgData.ContentType == constant.AtText {
+		go func() {
+			var conversationReq pbConversation.ModifyConversationFieldReq
+			var tag bool
+			var atUserID []string
+			conversation := pbConversation.Conversation{
+				OwnerUserID:      req.MsgData.SendID,
+				ConversationID:   utils.GetConversationIDBySessionType(req.MsgData.GroupID, constant.GroupChatType),
+				ConversationType: constant.GroupChatType,
+				GroupID:          req.MsgData.GroupID,
+			}
+			conversationReq.Conversation = &conversation
+			conversationReq.FieldType = constant.FieldGroupAtType
+			tagAll := utils.IsContain(constant.AtAllString, req.MsgData.AtUserIDList)
+			if tagAll {
+				atUserID = utils.DifferenceString([]string{constant.AtAllString}, req.MsgData.AtUserIDList)
+				if len(atUserID) == 0 { //just @everyone
+					conversationReq.UserIDList = memberUserIDList
+					conversation.GroupAtType = constant.AtAll
+				} else { //@Everyone and @other people
+					conversationReq.UserIDList = atUserID
+					conversation.GroupAtType = constant.AtAllAtMe
+					tag = true
+				}
+			} else {
+				conversationReq.UserIDList = req.MsgData.AtUserIDList
+				conversation.GroupAtType = constant.AtMe
+			}
+
+			err := m.Conversation.ModifyConversationField(ctx, &conversationReq)
+			if err != nil {
+				return
+			}
+
+			if tag {
+				conversationReq.UserIDList = utils.DifferenceString(atUserID, memberUserIDList)
+				conversation.GroupAtType = constant.AtAll
+				err := m.Conversation.ModifyConversationField(ctx, &conversationReq)
+				if err != nil {
+					return
+				}
+			}
+		}()
+	}
+	//
+
+	promePkg.PromeInc(promePkg.GroupChatMsgProcessSuccessCounter)
+	resp.SendTime = msgToMQSingle.MsgData.SendTime
+	resp.ServerMsgID = msgToMQSingle.MsgData.ServerMsgID
+	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
+	return resp, nil
+}
+
+func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, error error) {
+	resp = &msg.SendMsgResp{}
+	flag := isMessageHasReadEnabled(req.MsgData)
+	if !flag {
+		return nil, constant.ErrMessageHasReadDisable.Wrap()
+	}
+	m.encapsulateMsgData(req.MsgData)
+	if err := CallbackMsgModify(ctx, req); err != nil {
+		return nil, err
+	}
+	switch req.MsgData.SessionType {
+	case constant.SingleChatType:
+		return m.sendMsgSingleChat(ctx, req)
+	case constant.GroupChatType:
+		return m.sendMsgGroupChat(ctx, req)
+	case constant.NotificationChatType:
+		return m.sendMsgNotification(ctx, req)
+	case constant.SuperGroupChatType:
+		return m.sendMsgSuperGroupChat(ctx, req)
+	default:
+		return nil, constant.ErrArgs.Wrap("unknown sessionType")
+	}
+}
+
+func (m *msgServer) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
+	resp := new(sdkws.GetMaxAndMinSeqResp)
+	m2 := make(map[string]*sdkws.MaxAndMinSeq)
+	maxSeq, err := m.MsgInterface.GetUserMaxSeq(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	minSeq, err := m.MsgInterface.GetUserMinSeq(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	resp.MaxSeq = maxSeq
+	resp.MinSeq = minSeq
+	if len(req.GroupIDList) > 0 {
+		resp.GroupMaxAndMinSeq = make(map[string]*sdkws.MaxAndMinSeq)
+		for _, groupID := range req.GroupIDList {
+			maxSeq, err := m.MsgInterface.GetGroupMaxSeq(ctx, groupID)
+			if err != nil {
+				return nil, err
+			}
+			minSeq, err := m.MsgInterface.GetGroupMinSeq(ctx, groupID)
+			if err != nil {
+				return nil, err
+			}
+			m2[groupID] = &sdkws.MaxAndMinSeq{
+				MaxSeq: maxSeq,
+				MinSeq: minSeq,
+			}
+		}
+	}
+	return resp, nil
+}
+
+func (m *msgServer) PullMessageBySeqList(ctx context.Context, req *sdkws.PullMessageBySeqListReq) (*sdkws.PullMessageBySeqListResp, error) {
+	resp := &sdkws.PullMessageBySeqListResp{GroupMsgDataList: make(map[string]*sdkws.MsgDataList)}
+	msgs, err := m.MsgInterface.GetMessageListBySeq(ctx, req.UserID, req.SeqList)
+	if err != nil {
+		return nil, err
+	}
+	resp.List = msgs
+	for userID, list := range req.GroupSeqList {
+		msgs, err := m.MsgInterface.GetMessageListBySeq(ctx, userID, list.SeqList)
+		if err != nil {
+			return nil, err
+		}
+		resp.GroupMsgDataList[userID] = &sdkws.MsgDataList{
+			MsgDataList: msgs,
+		}
+	}
+	return resp, nil
+}

internal/rpc/msg/server.go

@@ -0,0 +1,72 @@
+package msg
+
+import (
+	"Open_IM/internal/common/check"
+	"Open_IM/pkg/common/db/controller"
+	"Open_IM/pkg/common/db/localcache"
+	"Open_IM/pkg/common/db/relation"
+	tablerelation "Open_IM/pkg/common/db/table/relation"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/openKeeper"
+
+	promePkg "Open_IM/pkg/common/prometheus"
+	"Open_IM/pkg/proto/msg"
+	"google.golang.org/grpc"
+)
+
+type msgServer struct {
+	RegisterCenter discoveryRegistry.SvcDiscoveryRegistry
+	MsgInterface   controller.MsgInterface
+	Group          *check.GroupChecker
+	User           *check.UserCheck
+	Conversation   *check.ConversationChecker
+	friend         *check.FriendChecker
+	*localcache.GroupLocalCache
+	black *check.BlackChecker
+}
+
+type deleteMsg struct {
+	UserID      string
+	OpUserID    string
+	SeqList     []uint32
+	OperationID string
+}
+
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
+	if err != nil {
+		return err
+	}
+	if err := mysql.AutoMigrate(&tablerelation.UserModel{}); err != nil {
+		return err
+	}
+	s := &msgServer{
+		Conversation: check.NewConversationChecker(client),
+		User:         check.NewUserCheck(client),
+		Group:        check.NewGroupChecker(client),
+		//MsgInterface: controller.MsgInterface(),
+		RegisterCenter:  client,
+		GroupLocalCache: localcache.NewGroupMemberIDsLocalCache(client),
+		black:           check.NewBlackChecker(client),
+		friend:          check.NewFriendChecker(client),
+	}
+	s.initPrometheus()
+	msg.RegisterMsgServer(server, s)
+	return nil
+}
+
+func (m *msgServer) initPrometheus() {
+	promePkg.NewMsgPullFromRedisSuccessCounter()
+	promePkg.NewMsgPullFromRedisFailedCounter()
+	promePkg.NewMsgPullFromMongoSuccessCounter()
+	promePkg.NewMsgPullFromMongoFailedCounter()
+	promePkg.NewSingleChatMsgRecvSuccessCounter()
+	promePkg.NewGroupChatMsgRecvSuccessCounter()
+	promePkg.NewWorkSuperGroupChatMsgRecvSuccessCounter()
+	promePkg.NewSingleChatMsgProcessSuccessCounter()
+	promePkg.NewSingleChatMsgProcessFailedCounter()
+	promePkg.NewGroupChatMsgProcessSuccessCounter()
+	promePkg.NewGroupChatMsgProcessFailedCounter()
+	promePkg.NewWorkSuperGroupChatMsgProcessSuccessCounter()
+	promePkg.NewWorkSuperGroupChatMsgProcessFailedCounter()
+}

internal/rpc/msg/super_group_notification.go

@@ -1,23 +0,0 @@
-package msg
-
-import (
-	"Open_IM/pkg/common/constant"
-	"Open_IM/pkg/common/log"
-	//sdk "Open_IM/pkg/proto/sdkws"
-	"Open_IM/pkg/utils"
-	//"github.com/golang/protobuf/jsonpb"
-	//"github.com/golang/protobuf/proto"
-)
-
-func SuperGroupNotification(operationID, sendID, recvID string) {
-	n := &NotificationMsg{
-		SendID:      sendID,
-		RecvID:      recvID,
-		MsgFrom:     constant.SysMsgType,
-		ContentType: constant.SuperGroupUpdateNotification,
-		SessionType: constant.SingleChatType,
-		OperationID: operationID,
-	}
-	log.NewInfo(operationID, utils.GetSelfFuncName(), string(n.Content))
-	Notification(n)
-}

internal/rpc/msg/utils.go

@@ -0,0 +1,37 @@
+package msg
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/proto/sdkws"
+	"Open_IM/pkg/utils"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+func isMessageHasReadEnabled(msgData *sdkws.MsgData) bool {
+	switch msgData.ContentType {
+	case constant.HasReadReceipt:
+		if config.Config.SingleMessageHasReadReceiptEnable {
+			return true
+		} else {
+			return false
+		}
+	case constant.GroupHasReadReceipt:
+		if config.Config.GroupMessageHasReadReceiptEnable {
+			return true
+		} else {
+			return false
+		}
+	}
+	return true
+}
+
+func IsNotFound(err error) bool {
+	switch utils.Unwrap(err) {
+	case redis.Nil, gorm.ErrRecordNotFound:
+		return true
+	default:
+		return false
+	}
+}

internal/rpc/user/user.go

@@ -1,187 +1,49 @@
 package user
 
 import (
+	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
-	"Open_IM/internal/common/rpc_server"
-	"Open_IM/internal/common/rpcserver"
-	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/config"
+	"Open_IM/internal/common/notification"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
 	tablerelation "Open_IM/pkg/common/db/table/relation"
-	"Open_IM/pkg/common/log"
-	prome "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/tokenverify"
 	"Open_IM/pkg/common/tracelog"
+	discoveryRegistry "Open_IM/pkg/discoveryregistry"
 	"Open_IM/pkg/proto/sdkws"
 	pbuser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
-
+	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
 )
 
 type userServer struct {
-	rpcPort         int
-	rpcRegisterName string
-	*rpcserver.RpcServer
 	controller.UserInterface
+	notification        *notification.Check
+	userCheck           *check.UserCheck
+	ConversationChecker *check.ConversationChecker
+	RegisterCenter      discoveryRegistry.SvcDiscoveryRegistry
 }
 
-func NewUserServer(port int) *userServer {
-	r, err := rpcserver.NewRpcServer(config.Config.RpcRegisterIP, port, config.Config.RpcRegisterName.OpenImUserName, config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema)
+func Start(client *openKeeper.ZkClient, server *grpc.Server) error {
+	mysql, err := relation.NewGormDB()
 	if err != nil {
-		panic(err)
+		return err
 	}
-	//mysql init
-	var mysql relation.Mysql
-	var model relation.UserGorm
-	err = mysql.InitConn().AutoMigrateModel(&model)
-	if err != nil {
-		panic("db init err:" + err.Error())
+	if err := mysql.AutoMigrate(&tablerelation.UserModel{}); err != nil {
+		return err
 	}
-	if mysql.GormConn() != nil {
-		model.DB = mysql.GormConn()
-	} else {
-		panic("db init err:" + "conn is nil")
-	}
-	return &userServer{RpcServer: r, UserInterface: controller.NewUserController(model.DB)}
+	pbuser.RegisterUserServer(server, &userServer{
+		UserInterface:  controller.NewUserController(mysql),
+		notification:   notification.NewCheck(client),
+		userCheck:      check.NewUserCheck(client),
+		RegisterCenter: client,
+	})
+	return nil
 }
 
-func (s *userServer) Run() {
-	operationID := utils.OperationIDGenerator()
-	log.NewInfo(operationID, "rpc user start...")
-	listener, address, err := rpcserver.GetTcpListen(config.Config.ListenIP, s.Port)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "listen ok ", address)
-	defer listener.Close()
-	//grpc server
-	var grpcOpts []grpc.ServerOption
-	if config.Config.Prometheus.Enable {
-		prome.NewGrpcRequestCounter()
-		prome.NewGrpcRequestFailedCounter()
-		prome.NewGrpcRequestSuccessCounter()
-		grpcOpts = append(grpcOpts, []grpc.ServerOption{
-			// grpc.UnaryInterceptor(prome.UnaryServerInterceptorProme),
-			grpc.StreamInterceptor(grpcPrometheus.StreamServerInterceptor),
-			grpc.UnaryInterceptor(grpcPrometheus.UnaryServerInterceptor),
-		}...)
-	}
-	srv := grpc.NewServer(grpcOpts...)
-	defer srv.GracefulStop()
-	//Service registers with etcd
-	pbuser.RegisterUserServer(srv, s)
-
-	err = srv.Serve(listener)
-	if err != nil {
-		panic(err)
-	}
-	log.NewInfo(operationID, "rpc  user success")
-}
-
-// ok
-//func (s *userServer) SyncJoinedGroupMemberFaceURL(ctx context.Context, userID string, faceURL string, operationID string, opUserID string) {
-//	members, err := s.GetJoinedGroupMembers(ctx, userID)
-//	if err != nil {
-//		return
-//	}
-//	groupIDs := make([]string, 0)
-//	for _, v := range members {
-//		groupIDs = append(groupIDs, v.GroupID)
-//	}
-//	if s.SetGroupMemberInfo(ctx, "", faceURL, "", 0, groupIDs, userID) != nil {
-//		return
-//	}
-//	for _, v := range groupIDs {
-//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-//	}
-//}
-
-// ok
-//func (s *userServer) SyncJoinedGroupMemberNickname(ctx context.Context, userID string, newNickname, oldNickname string, operationID string, opUserID string) {
-//	members, err := s.GetJoinedGroupMembers(ctx, userID)
-//	if err != nil {
-//		return
-//	}
-//	groupIDs := make([]string, 0)
-//	for _, v := range members {
-//		if v.Nickname == oldNickname {
-//			groupIDs = append(groupIDs, v.GroupID)
-//		}
-//	}
-//	s.SetGroupMemberInfo(ctx, newNickname, "", "", 0, groupIDs, userID)
-//	for _, v := range groupIDs {
-//		chat.GroupMemberInfoSetNotification(operationID, opUserID, v, userID)
-//	}
-//}
-
-// 设置群头像
-//func (s *userServer) SetGroupMemberInfo(ctx context.Context, nickname, faceURL, ex string, roleLevel int32, groupIDs []string, userID string) (err error) {
-//
-//	req := pbgroup.SetGroupMemberInfo{UserID: userID}
-//	if nickname != "" {
-//		req.Nickname = &wrappers.StringValue{Value: nickname}
-//	}
-//	if faceURL != "" {
-//		req.FaceURL = &wrappers.StringValue{Value: faceURL}
-//	}
-//	if ex != "" {
-//		req.Ex = &wrappers.StringValue{Value: ex}
-//	}
-//	if roleLevel != 0 {
-//		req.RoleLevel = &wrappers.Int32Value{Value: roleLevel}
-//	}
-//
-//	setGroupMemberInfoReq := &pbgroup.SetGroupMemberInfoReq{}
-//	for _, v := range groupIDs {
-//		req.GroupID = v
-//		setGroupMemberInfoReq.Members = append(setGroupMemberInfoReq.Members, &req)
-//	}
-//	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
-//	if err != nil {
-//		return err
-//	}
-//	client := group.NewGroupClient(conn)
-//	_, err = client.SetGroupMemberInfo(ctx, setGroupMemberInfoReq)
-//	return
-//}
-
-// 获取加入的群成员信息
-//func (s *userServer) GetJoinedGroupMembers(ctx context.Context, userID string) (members []*sdkws.GroupMemberFullInfo, err error) {
-//	conn, err := s.RegisterCenter.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
-//	if err != nil {
-//		return nil, err
-//	}
-//
-//	client := group.NewGroupClient(conn)
-//	for {
-//		idx := int32(0)
-//		req := pbgroup.GetJoinedGroupListReq{FromUserID: userID, Pagination: &sdkws.RequestPagination{PageNumber: idx, ShowNumber: constant.ShowNumber}}
-//		resp, err := client.GetJoinedGroupList(ctx, &req)
-//		if err != nil {
-//			return nil, err
-//		}
-//		groupIDs := make([]string, 0)
-//
-//		for _, v := range resp.Groups {
-//			groupIDs = append(groupIDs, v.GroupID)
-//		}
-//
-//		client.GetGroupMembersInfo()
-//
-//		if len(resp.Groups) < constant.ShowNumber {
-//			break
-//		}
-//		idx++
-//	}
-//
-//	return
-//}
-
 // ok
 func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesignateUsersReq) (resp *pbuser.GetDesignateUsersResp, err error) {
 	resp = &pbuser.GetDesignateUsersResp{}
@@ -229,11 +91,11 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	}
 	go func() {
 		for _, v := range friends {
-			chat.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
+			s.notification.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
 		}
 	}()
 
-	chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
+	s.notification.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
 
 	return resp, nil
 }
@@ -249,7 +111,7 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
 	if err := s.UpdateByMap(ctx, req.UserID, m); err != nil {
 		return nil, err
 	}
-	chat.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
+	s.notification.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
 	return resp, nil
 }