Merge remote-tracking branch 'origin/v2.3.0release' into v2.3.0release

config/config.yaml

@@ -341,6 +341,10 @@ callback:
     enable: false
     callbackTimeOut: 2
     callbackFailedContinue: true # 回调超时是否继续
+  callbackBeforeMemberJoinGroup:
+    enable: false
+    callbackTimeOut: 2
+    callbackFailedContinue: true # 回调超时是否继续
 
 notification:
   groupCreated:

internal/cms_api/admin/admin.go

@@ -58,6 +58,40 @@ func init() {
 	}
 }
 
+func GetUserToken(c *gin.Context) {
+	var (
+		req    apiStruct.GetUserTokenRequest
+		resp   apiStruct.GetUserTokenResponse
+		reqPb  pbAdmin.GetUserTokenReq
+		respPb *pbAdmin.GetUserTokenResp
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	reqPb.OperationID = req.OperationID
+	reqPb.UserID = req.UserID
+	reqPb.PlatformID = req.PlatFormID
+	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName, reqPb.OperationID)
+	if etcdConn == nil {
+		errMsg := reqPb.OperationID + "getcdv3.GetDefaultConn == nil"
+		log.NewError(reqPb.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	client := pbAdmin.NewAdminCMSClient(etcdConn)
+	respPb, err := client.GetUserToken(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+	resp.Token = respPb.Token
+	resp.ExpTime = respPb.ExpTime
+	c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg, "data": resp})
+}
+
 // register
 func AdminLogin(c *gin.Context) {
 	var (

internal/cms_api/middleware/jwt_auth.go

@@ -1,6 +1,7 @@
 package middleware
 
 import (
+	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/utils"
@@ -20,6 +21,11 @@ func JWTAuth() gin.HandlerFunc {
 			c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": errInfo})
 			return
 		} else {
+			if !utils.IsContain(userID, config.Config.Manager.AppManagerUid) {
+				c.Abort()
+				c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": "user is not admin"})
+				return
+			}
 			log.NewInfo("0", utils.GetSelfFuncName(), "failed: ", errInfo)
 		}
 	}

internal/cms_api/router.go

@@ -29,6 +29,8 @@ func NewGinRouter() *gin.Engine {
 	{
 		adminRouterGroup.POST("/login", admin.AdminLogin)
 		adminRouterGroup.Use(middleware.JWTAuth())
+		adminRouterGroup.POST("/get_user_token", admin.GetUserToken)
+
 		adminRouterGroup.POST("/add_user_register_add_friend_id", admin.AddUserRegisterAddFriendIDList)
 		adminRouterGroup.POST("/reduce_user_register_reduce_friend_id", admin.ReduceUserRegisterAddFriendIDList)
 		adminRouterGroup.POST("/get_user_register_reduce_friend_id_list", admin.GetUserRegisterAddFriendIDList)

internal/cron_task/clear_msg_test.go

@@ -12,19 +12,6 @@ import (
 	"time"
 )
 
-func init() {
-	cmd := exec.Command("/bin/bash", "CONFIG_NAME=../../")
-	_, err := cmd.StdoutPipe()
-	if err != nil {
-		return
-	}
-
-	//执行命令
-	if err := cmd.Start(); err != nil {
-		return
-	}
-}
-
 func getMsgListFake(num int) []*pbMsg.MsgDataToMQ {
 	var msgList []*pbMsg.MsgDataToMQ
 	for i := 1; i < num; i++ {

internal/rpc/admin_cms/admin_cms.go

@@ -133,6 +133,24 @@ func (s *adminCMSServer) AdminLogin(_ context.Context, req *pbAdminCMS.AdminLogi
 	return resp, nil
 }
 
+func (s *adminCMSServer) GetUserToken(_ context.Context, req *pbAdminCMS.GetUserTokenReq) (*pbAdminCMS.GetUserTokenResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbAdminCMS.GetUserTokenResp{
+		CommonResp: &pbAdminCMS.CommonResp{},
+	}
+	token, expTime, err := token_verify.CreateToken(req.UserID, int(req.PlatformID))
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "generate token failed", "userID: ", req.UserID, req.PlatformID, err.Error())
+		resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode
+		resp.CommonResp.ErrMsg = err.Error()
+		return resp, nil
+	}
+	resp.Token = token
+	resp.ExpTime = expTime
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String())
+	return resp, nil
+}
+
 func (s *adminCMSServer) AddUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.AddUserRegisterAddFriendIDListReq) (*pbAdminCMS.AddUserRegisterAddFriendIDListResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp := &pbAdminCMS.AddUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}

internal/rpc/group/callback.go

@@ -4,6 +4,7 @@ import (
 	cbApi "Open_IM/pkg/call_back_struct"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
 	"Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	pbGroup "Open_IM/pkg/proto/group"
@@ -19,6 +20,9 @@ func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) cbApi.CommonCallback
 	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), req.String())
 	commonCallbackReq := &cbApi.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
+		OperationID:     req.OperationID,
+		GroupInfo:       *req.GroupInfo,
+		InitMemberList:  req.InitMemberList,
 	}
 	resp := &cbApi.CallbackBeforeCreateGroupResp{
 		CommonCallbackResp: &callbackResp,
@@ -41,7 +45,7 @@ func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) cbApi.CommonCallback
 			req.GroupInfo.GroupID = *resp.GroupID
 		}
 		if resp.GroupName != nil {
-			req.GroupInfo.GroupName = *resp.GroupID
+			req.GroupInfo.GroupName = *resp.GroupName
 		}
 		if resp.Notification != nil {
 			req.GroupInfo.Notification = *resp.Notification
@@ -68,7 +72,7 @@ func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) cbApi.CommonCallback
 			req.GroupInfo.GroupType = *resp.GroupType
 		}
 		if resp.NeedVerification != nil {
-			req.GroupInfo.NeedVerification = *resp.GroupType
+			req.GroupInfo.NeedVerification = *resp.NeedVerification
 		}
 		if resp.LookMemberInfo != nil {
 			req.GroupInfo.LookMemberInfo = *resp.LookMemberInfo
@@ -76,3 +80,49 @@ func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) cbApi.CommonCallback
 	}
 	return callbackResp
 }
+
+func CallbackBeforeMemberJoinGroup(operationID string, groupMember *db.GroupMember, groupEx string) cbApi.CommonCallbackResp {
+	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
+	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
+		return callbackResp
+	}
+	log.NewDebug(operationID, "args: ", *groupMember)
+	callbackReq := cbApi.CallbackBeforeMemberJoinGroupReq{
+		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
+		OperationID:     operationID,
+		GroupID:         groupMember.GroupID,
+		UserID:          groupMember.UserID,
+		Ex:              groupMember.Ex,
+		GroupEx:         groupEx,
+	}
+	resp := &cbApi.CallbackBeforeMemberJoinGroupResp{
+		CommonCallbackResp: &callbackResp,
+	}
+	if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeMemberJoinGroupCommand, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup.CallbackTimeOut); err != nil {
+		callbackResp.ErrCode = http2.StatusInternalServerError
+		callbackResp.ErrMsg = err.Error()
+		if !config.Config.Callback.CallbackBeforeMemberJoinGroup.CallbackFailedContinue {
+			callbackResp.ActionCode = constant.ActionForbidden
+			return callbackResp
+		} else {
+			callbackResp.ActionCode = constant.ActionAllow
+			return callbackResp
+		}
+	}
+	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
+	}
+	return callbackResp
+}

internal/rpc/group/group.go

@@ -20,6 +20,7 @@ import (
 	"Open_IM/pkg/utils"
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"net"
 	"strconv"
@@ -157,6 +158,16 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	groupMember := db.GroupMember{}
 	us := &db.User{}
 	if req.OwnerUserID != "" {
+		var userIDList []string
+		for _, v := range req.InitMemberList {
+			userIDList = append(userIDList, v.UserID)
+		}
+		userIDList = append(userIDList, req.OwnerUserID)
+		if err := s.DelGroupAndUserCache(req.OperationID, "", userIDList); err != nil {
+			log.NewError(req.OperationID, "DelGroupAndUserCache failed, ", err.Error(), userIDList)
+			return &pbGroup.CreateGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}, nil
+		}
+
 		us, err = imdb.GetUserByUserID(req.OwnerUserID)
 		if err != nil {
 			log.NewError(req.OperationID, "GetUserByUserID failed ", err.Error(), req.OwnerUserID)
@@ -165,6 +176,21 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		//to group member
 		groupMember = db.GroupMember{GroupID: groupId, RoleLevel: constant.GroupOwner, OperatorUserID: req.OpUserID, JoinSource: constant.JoinByInvitation, InviterUserID: req.OpUserID}
 		utils.CopyStructFields(&groupMember, us)
+		callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &groupMember, groupInfo.Ex)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+			return &pbGroup.CreateGroupResp{
+				ErrCode: int32(callbackResp.ErrCode),
+				ErrMsg:  callbackResp.ErrMsg,
+			}, nil
+		}
+
 		err = imdb.InsertIntoGroupMember(groupMember)
 		if err != nil {
 			log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
@@ -188,6 +214,17 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			groupMember.JoinSource = constant.JoinByInvitation
 			groupMember.InviterUserID = req.OpUserID
 			utils.CopyStructFields(&groupMember, us)
+			callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &groupMember, groupInfo.Ex)
+			if callbackResp.ErrCode != 0 {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+			}
+			if callbackResp.ActionCode != constant.ActionAllow {
+				if callbackResp.ErrCode == 0 {
+					callbackResp.ErrCode = 201
+				}
+				log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+				continue
+			}
 			err = imdb.InsertIntoGroupMember(groupMember)
 			if err != nil {
 				log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
@@ -231,11 +268,6 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if len(okUserIDList) != 0 {
 		log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String())
 		if req.GroupInfo.GroupType != constant.SuperGroup {
-			for _, userID := range okUserIDList {
-				if err := rocksCache.DelJoinedGroupIDListFromCache(userID); err != nil {
-					log.NewWarn(req.OperationID, utils.GetSelfFuncName(), userID, err.Error())
-				}
-			}
 			chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
 		} else {
 			for _, userID := range okUserIDList {
@@ -362,7 +394,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		log.NewInfo(req.OperationID, "InviteUserToGroup rpc return ", resp)
 		return &resp, nil
 	}
-	//
+	if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, req.InvitedUserIDList); err != nil {
+		log.NewError(req.OperationID, "DelGroupAndUserCache failed", err.Error())
+		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}, nil
+	}
 	//from User:  invite: applicant
 	//to user:  invite: invited
 	var okUserIDList []string
@@ -392,6 +427,15 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			toInsertInfo.OperatorUserID = req.OpUserID
 			toInsertInfo.InviterUserID = req.OpUserID
 			toInsertInfo.JoinSource = constant.JoinByInvitation
+			callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &toInsertInfo, groupInfo.Ex)
+			if callbackResp.ErrCode != 0 {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+			}
+			if callbackResp.ActionCode != constant.ActionAllow {
+				log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+				continue
+			}
+
 			err = imdb.InsertIntoGroupMember(toInsertInfo)
 			if err != nil {
 				log.NewError(req.OperationID, "InsertIntoGroupMember failed ", req.GroupID, toUserInfo.UserID, toUserInfo.Nickname, toUserInfo.FaceURL)
@@ -473,40 +517,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}, nil
 		}
 	}
-
-	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}, nil
-	}
-	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
-		GroupID:     req.GroupID,
-		OperationID: req.OperationID,
-	})
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
-		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
-	}
-	if cacheResp.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
-		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
-	}
-	if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
-	}
-	if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
 	if groupInfo.GroupType != constant.SuperGroup {
-		for _, userID := range okUserIDList {
-			err = rocksCache.DelJoinedGroupIDListFromCache(userID)
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userID)
-			}
-		}
-
 		chat.MemberInvitedNotification(req.OperationID, req.GroupID, req.OpUserID, req.Reason, okUserIDList)
 	} else {
 		for _, v := range req.InvitedUserIDList {
@@ -634,7 +645,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			log.NewError(req.OperationID, "failed, kick list 0")
 			return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}, nil
 		}
-
+		if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, req.KickedUserIDList); err != nil {
+			log.NewError(req.OperationID, "DelGroupAndUserCache failed", err.Error())
+			return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}, nil
+		}
 		//remove
 		for _, v := range req.KickedUserIDList {
 			kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(req.GroupID, v)
@@ -701,42 +715,12 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		}
 	}
 
-	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: errMsg}, nil
-	}
-	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
-		GroupID:     req.GroupID,
-		OperationID: req.OperationID,
-	})
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
-		return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
-	}
-	if cacheResp.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
-		return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
-	}
-	if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
-	}
-
 	if groupInfo.GroupType != constant.SuperGroup {
 		for _, userID := range okUserIDList {
-			err = rocksCache.DelJoinedGroupIDListFromCache(userID)
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), userID)
-			}
 			if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, userID); err != nil {
 				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
 			}
 		}
-		if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-		}
 		chat.MemberKickedNotification(req, okUserIDList)
 	} else {
 		for _, userID := range okUserIDList {
@@ -761,7 +745,6 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	log.NewInfo(req.OperationID, "GetGroupMembersInfo args ", req.String())
 	var resp pbGroup.GetGroupMembersInfoResp
 	resp.MemberList = []*open_im_sdk.GroupMemberFullInfo{}
-
 	for _, userID := range req.MemberList {
 		groupMember, err := rocksCache.GetGroupMemberInfoFromCache(req.GroupID, userID)
 		if err != nil {
@@ -773,24 +756,6 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 		memberNode.JoinTime = int32(groupMember.JoinTime.Unix())
 		resp.MemberList = append(resp.MemberList, &memberNode)
 	}
-
-	//groupMembers, err := rocksCache.GetAllGroupMembersInfoFromCache(req.GroupID)
-	//if err != nil {
-	//	log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
-	//	resp.ErrCode = constant.ErrDB.ErrCode
-	//	resp.ErrMsg = constant.ErrDB.ErrMsg
-	//	return &resp, nil
-	//}
-	//for _, member := range groupMembers {
-	//	if utils.IsContain(member.UserID, req.MemberList) {
-	//		var memberNode open_im_sdk.GroupMemberFullInfo
-	//		utils.CopyStructFields(&memberNode, member)
-	//		memberNode.JoinTime = int32(member.JoinTime.Unix())
-	//		resp.MemberList = append(resp.MemberList, &memberNode)
-	//	}
-	//}
-
-	resp.ErrCode = 0
 	log.NewInfo(req.OperationID, "GetGroupMembersInfo rpc return ", resp.String())
 	return &resp, nil
 }
@@ -875,7 +840,11 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 		log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.GroupID, req.FromUserID)
 		return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-
+	groupInfo, err := rocksCache.GetGroupInfoFromCache(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupInfoFromCache failed ", err.Error(), req.GroupID, req.FromUserID)
+		return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
 	if req.HandleResult == constant.GroupResponseAgree {
 		user, err := imdb.GetUserByUserID(req.FromUserID)
 		if err != nil {
@@ -891,6 +860,22 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 		member.Nickname = user.Nickname
 		member.JoinSource = request.JoinSource
 		member.InviterUserID = request.InviterUserID
+		callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &member, groupInfo.Ex)
+		if callbackResp.ErrCode != 0 {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+		}
+		if callbackResp.ActionCode != constant.ActionAllow {
+			if callbackResp.ErrCode == 0 {
+				callbackResp.ErrCode = 201
+			}
+			log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+			return &pbGroup.GroupApplicationResponseResp{
+				CommonResp: &pbGroup.CommonResp{
+					ErrCode: int32(callbackResp.ErrCode),
+					ErrMsg:  callbackResp.ErrMsg,
+				},
+			}, nil
+		}
 		err = imdb.InsertIntoGroupMember(member)
 		if err != nil {
 			log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
@@ -980,7 +965,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
-	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	groupInfo, err := rocksCache.GetGroupInfoFromCache(req.GroupID)
 	if err != nil {
 		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@@ -1000,40 +985,34 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			//to group member
 			groupMember := db.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: req.OpUserID}
 			utils.CopyStructFields(&groupMember, us)
+			callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &groupMember, groupInfo.Ex)
+			if callbackResp.ErrCode != 0 {
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
+			}
+			if callbackResp.ActionCode != constant.ActionAllow {
+				if callbackResp.ErrCode == 0 {
+					callbackResp.ErrCode = 201
+				}
+				log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
+				return &pbGroup.JoinGroupResp{
+					CommonResp: &pbGroup.CommonResp{
+						ErrCode: int32(callbackResp.ErrCode),
+						ErrMsg:  callbackResp.ErrMsg,
+					},
+				}, nil
+			}
+
+			if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, []string{req.OpUserID}); err != nil {
+				log.NewError(req.OperationID, "DelGroupAndUserCache failed, ", err.Error(), req.OpUserID)
+				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+			}
+
 			err = imdb.InsertIntoGroupMember(groupMember)
 			if err != nil {
 				log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
 				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 			}
-			etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-			if etcdConn == nil {
-				errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-				log.NewError(req.OperationID, errMsg)
-				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: constant.ErrInternal.ErrMsg}}, nil
-			}
-			cacheClient := pbCache.NewCacheClient(etcdConn)
-			cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
-				GroupID:     req.GroupID,
-				OperationID: req.OperationID,
-			})
-			if err != nil {
-				log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
-				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-			}
-			if cacheResp.CommonResp.ErrCode != 0 {
-				log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
-				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-			}
-			err = rocksCache.DelJoinedGroupIDListFromCache(req.OpUserID)
-			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-			}
-			if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
-			}
-			if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-			}
+
 			chat.MemberEnterDirectlyNotification(req.GroupID, req.OpUserID, req.OperationID)
 			log.NewInfo(req.OperationID, "JoinGroup rpc return ")
 			return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1042,7 +1021,6 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
 		}
 	}
-
 	var groupRequest db.GroupRequest
 	groupRequest.UserID = req.OpUserID
 	groupRequest.ReqMsg = req.ReqMessage
@@ -1053,13 +1031,11 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		log.NewError(req.OperationID, "InsertIntoGroupRequest failed ", err.Error(), groupRequest)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-
 	//_, err = imdb.GetGroupMemberListByGroupIDAndRoleLevel(req.GroupID, constant.GroupOwner)
 	//if err != nil {
 	//	log.NewError(req.OperationID, "GetGroupMemberListByGroupIDAndRoleLevel failed ", err.Error(), req.GroupID, constant.GroupOwner)
 	//	return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 	//}
-
 	chat.JoinGroupApplicationNotification(req)
 	log.NewInfo(req.OperationID, "JoinGroup rpc return ")
 	return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1079,6 +1055,11 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 			return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 		}
 
+		if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, []string{req.OpUserID}); err != nil {
+			log.NewError(req.OperationID, "DelGroupAndUserCache failed, ", err.Error(), req.OpUserID)
+			return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+		}
+
 		err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, req.OpUserID)
 		if err != nil {
 			log.NewError(req.OperationID, "DeleteGroupMemberByGroupIdAndUserId failed ", err.Error(), req.GroupID, req.OpUserID)
@@ -1121,35 +1102,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		}
 	}
 
-	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: constant.ErrInternal.ErrMsg}}, nil
-	}
-	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
-		GroupID:     req.GroupID,
-		OperationID: req.OperationID,
-	})
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
-		return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-	}
-	if cacheResp.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
-		return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-	}
-	if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
-	}
 	if groupInfo.GroupType != constant.SuperGroup {
-		if err := rocksCache.DelJoinedGroupIDListFromCache(req.OpUserID); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.OpUserID)
-		}
-		if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-		}
 		if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.OpUserID); err != nil {
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
 		}
@@ -1158,10 +1111,13 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		if err := rocksCache.DelJoinedSuperGroupIDListFromCache(req.OpUserID); err != nil {
 			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.OpUserID)
 		}
+		if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), req.GroupID, err.Error())
+		}
 		chat.SuperGroupNotification(req.OperationID, req.OpUserID, req.OpUserID)
 	}
-	log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}})
-	return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+	log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{}})
+	return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{}}, nil
 }
 
 func hasAccess(req *pbGroup.SetGroupInfoReq) bool {
@@ -1259,16 +1215,15 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		groupInfo.NotificationUserID = req.OpUserID
 		groupInfo.NotificationUpdateTime = time.Now()
 	}
+	if err := rocksCache.DelGroupInfoFromCache(req.GroupInfoForSet.GroupID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelGroupInfoFromCache failed ", err.Error(), req.GroupInfoForSet.GroupID)
+		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
 	err = imdb.SetGroupInfo(groupInfo)
 	if err != nil {
 		log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo)
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupInfoFromCache(req.GroupInfoForSet.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "DelGroupInfoFromCache failed ", err.Error(), req.GroupInfoForSet.GroupID)
-		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-	}
-
 	log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
 	if changedType != 0 {
 		chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification)
@@ -1339,6 +1294,18 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
 		log.NewError(req.OperationID, "same owner ", req.OldOwnerUserID, req.NewOwnerUserID)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
 	}
+	err = rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.NewOwnerUserID)
+	if err != nil {
+		log.NewError(req.OperationID, "DelGroupMemberInfoFromCache failed ", req.GroupID, req.NewOwnerUserID)
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+
+	}
+	err = rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.OldOwnerUserID)
+	if err != nil {
+		log.NewError(req.OperationID, "DelGroupMemberInfoFromCache failed ", req.GroupID, req.OldOwnerUserID)
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
+
 	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
 	err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
@@ -1351,14 +1318,7 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
 		log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	err = rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.NewOwnerUserID)
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberInfoFromCache failed ", req.GroupID, req.NewOwnerUserID)
-	}
-	err = rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.OldOwnerUserID)
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberInfoFromCache failed ", req.GroupID, req.OldOwnerUserID)
-	}
+
 	chat.GroupOwnerTransferredNotification(req)
 	return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 
@@ -1503,6 +1463,15 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 
+	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
+	if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, nil); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
+
 	err := imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusDismissed)
 	if err != nil {
 		log.NewError(req.OperationID, "OperateGroupStatus failed ", req.GroupID, constant.GroupStatusDismissed)
@@ -1554,34 +1523,8 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 		if err != nil {
 			log.NewError(req.OperationID, "DeleteGroupMemberByGroupID failed ", req.GroupID)
 			return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
-
 		}
 	}
-	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
-	if etcdConn == nil {
-		errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
-		log.NewError(req.OperationID, errMsg)
-		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 500, ErrMsg: errMsg}}, nil
-	}
-	cacheClient := pbCache.NewCacheClient(etcdConn)
-	cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
-		GroupID:     req.GroupID,
-		OperationID: req.OperationID,
-	})
-	if err != nil {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
-		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 500, ErrMsg: err.Error()}}, nil
-	}
-	if cacheResp.CommonResp.ErrCode != 0 {
-		log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
-		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: cacheResp.CommonResp.ErrCode, ErrMsg: cacheResp.CommonResp.ErrMsg}}, nil
-	}
-	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
-	if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 }
@@ -1605,7 +1548,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
-	mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID)
+	mutedInfo, err := rocksCache.GetGroupMemberInfoFromCache(req.GroupID, req.UserID)
 	if err != nil {
 		errMsg := req.OperationID + " GetGroupMemberInfoByGroupIDAndUserID failed " + req.GroupID + req.UserID + err.Error()
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
@@ -1619,17 +1562,17 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	}
 
+	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID, req.UserID)
+		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
 	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
-
 	groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano())
 	err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		log.Error(req.OperationID, "UpdateGroupMemberInfo failed ", err.Error(), groupMemberInfo)
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
 	chat.GroupMemberMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, req.MutedSeconds)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1663,6 +1606,10 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 		errMsg := req.OperationID + " mutedInfo.RoleLevel == constant.GroupAdmin " + req.GroupID + req.UserID
 		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	}
+	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
 
 	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
 	groupMemberInfo.MuteEndTime = time.Unix(0, 0)
@@ -1671,9 +1618,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 		log.Error(req.OperationID, "UpdateGroupMemberInfo failed ", err.Error(), groupMemberInfo)
 		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
+
 	chat.GroupMemberCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1707,15 +1652,17 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 	//	errMsg := req.OperationID + " mutedInfo.RoleLevel == constant.GroupAdmin " + req.GroupID + req.OpUserID + err.Error()
 	//	return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	//}
+	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
 
 	err = imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusMuted)
 	if err != nil {
 		log.Error(req.OperationID, "OperateGroupStatus failed ", err.Error(), req.GroupID, constant.GroupStatusMuted)
 		return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
+
 	chat.GroupMutedNotification(req.OperationID, req.OpUserID, req.GroupID)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1723,7 +1670,6 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 
 func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-
 	opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID)
 	if err != nil {
 		errMsg := req.OperationID + " getGroupUserLevel failed " + req.GroupID + req.OpUserID + err.Error()
@@ -1735,7 +1681,6 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 		log.Error(req.OperationID, errMsg)
 		return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	}
-
 	//mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.)
 	//if err != nil {
 	//	errMsg := req.OperationID + " GetGroupMemberInfoByGroupIDAndUserID failed " + req.GroupID + req.OpUserID + err.Error()
@@ -1750,14 +1695,16 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	//	return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
 	//}
 	log.Debug(req.OperationID, "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk})
+	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
 	err = imdb.UpdateGroupInfoDefaultZero(req.GroupID, map[string]interface{}{"status": constant.GroupOk})
 	if err != nil {
 		log.Error(req.OperationID, "UpdateGroupInfoDefaultZero failed ", err.Error(), req.GroupID)
 		return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
+
 	chat.GroupCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1785,15 +1732,17 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
 	} else {
 		groupMemberInfo.Nickname = req.Nickname
 	}
+
+	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: err.Error()}}, nil
+	}
 	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		errMsg := req.OperationID + " UpdateGroupMemberInfo failed " + err.Error()
 		log.Error(req.OperationID, errMsg)
 		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
-	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
-	}
 	chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@@ -1802,6 +1751,12 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
 func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (resp *pbGroup.SetGroupMemberInfoResp, err error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp = &pbGroup.SetGroupMemberInfoResp{CommonResp: &pbGroup.CommonResp{}}
+	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+		resp.CommonResp.ErrMsg = err.Error()
+		return resp, nil
+	}
 	groupMember := db.GroupMember{
 		GroupID: req.GroupID,
 		UserID:  req.UserID,
@@ -1826,9 +1781,6 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		resp.CommonResp.ErrMsg = constant.ErrDB.ErrMsg + ":" + err.Error()
 		return resp, nil
 	}
-	if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, req.UserID); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID, req.UserID)
-	}
 	if req.RoleLevel != nil {
 		switch req.RoleLevel.Value {
 		case constant.GroupOrdinaryUsers:
@@ -1867,3 +1819,47 @@ func (s *groupServer) GetGroupAbstractInfo(c context.Context, req *pbGroup.GetGr
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String())
 	return resp, nil
 }
+
+func (s *groupServer) DelGroupAndUserCache(operationID, groupID string, userIDList []string) error {
+	if groupID != "" {
+		etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, operationID)
+		if etcdConn == nil {
+			errMsg := operationID + "getcdv3.GetDefaultConn == nil"
+			log.NewError(operationID, errMsg)
+			return errors.New("etcdConn is nil")
+		}
+		cacheClient := pbCache.NewCacheClient(etcdConn)
+		cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
+			GroupID:     groupID,
+			OperationID: operationID,
+		})
+		if err != nil {
+			log.NewError(operationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
+			return utils.Wrap(err, "")
+		}
+		if cacheResp.CommonResp.ErrCode != 0 {
+			log.NewError(operationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
+			return errors.New(fmt.Sprintf("errMsg is %s, errCode is %d", cacheResp.CommonResp.ErrMsg, cacheResp.CommonResp.ErrCode))
+		}
+		err = rocksCache.DelGroupMemberListHashFromCache(groupID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), groupID, err.Error())
+			return utils.Wrap(err, "")
+		}
+		err = rocksCache.DelGroupMemberNumFromCache(groupID)
+		if err != nil {
+			log.NewError(operationID, utils.GetSelfFuncName(), err.Error(), groupID)
+			return utils.Wrap(err, "")
+		}
+	}
+	if userIDList != nil {
+		for _, userID := range userIDList {
+			err := rocksCache.DelJoinedGroupIDListFromCache(userID)
+			if err != nil {
+				log.NewError(operationID, utils.GetSelfFuncName(), err.Error())
+				return utils.Wrap(err, "")
+			}
+		}
+	}
+	return nil
+}

internal/rpc/msg/group_notification.go

@@ -416,8 +416,6 @@ func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
 	}
 
 	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
-	//	groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, "", req.OpUserID, req.OperationID)
-
 }
 
 //message ApplicationProcessedTips{

internal/rpc/msg/send_msg.go

@@ -174,9 +174,13 @@ func (rpc *rpcChat) messageVerification(data *pbChat.SendMsgReq) (bool, int32, s
 		if token_verify.IsManagerUserID(data.MsgData.SendID) {
 			return true, 0, "", userIDList
 		}
-		if !utils.IsContain(data.MsgData.SendID, userIDList) {
-			//return returnMsg(&replay, pb, 202, "you are not in group", "", 0)
-			return false, 202, "you are not in group", nil
+		if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
+			return true, 0, "", userIDList
+		} else {
+			if !utils.IsContain(data.MsgData.SendID, userIDList) {
+				//return returnMsg(&replay, pb, 202, "you are not in group", "", 0)
+				return false, 202, "you are not in group", nil
+			}
 		}
 		isMute, err := userIsMuteInGroup(data.MsgData.GroupID, data.MsgData.SendID)
 		if err != nil {
@@ -233,9 +237,13 @@ func (rpc *rpcChat) messageVerification(data *pbChat.SendMsgReq) (bool, int32, s
 			if token_verify.IsManagerUserID(data.MsgData.SendID) {
 				return true, 0, "", userIDList
 			}
-			if !utils.IsContain(data.MsgData.SendID, userIDList) {
-				//return returnMsg(&replay, pb, 202, "you are not in group", "", 0)
-				return false, 202, "you are not in group", nil
+			if data.MsgData.ContentType <= constant.NotificationEnd && data.MsgData.ContentType >= constant.NotificationBegin {
+				return true, 0, "", userIDList
+			} else {
+				if !utils.IsContain(data.MsgData.SendID, userIDList) {
+					//return returnMsg(&replay, pb, 202, "you are not in group", "", 0)
+					return false, 202, "you are not in group", nil
+				}
 			}
 			isMute, err := userIsMuteInGroup(data.MsgData.GroupID, data.MsgData.SendID)
 			if err != nil {

pkg/call_back_struct/group.go

@@ -1,12 +1,15 @@
 package call_back_struct
 
 import (
+	"Open_IM/pkg/proto/group"
 	commonPb "Open_IM/pkg/proto/sdk_ws"
 )
 
 type CallbackBeforeCreateGroupReq struct {
 	CallbackCommand string `json:"callbackCommand"`
+	OperationID     string `json:"operationID"`
 	commonPb.GroupInfo
+	InitMemberList []*group.GroupAddMemberInfo `json:"initMemberList"`
 }
 
 type CallbackBeforeCreateGroupResp struct {
@@ -25,3 +28,21 @@ type CallbackBeforeCreateGroupResp struct {
 	LookMemberInfo    *int32  `json:"lookMemberInfo"`
 	ApplyMemberFriend *int32  `json:"applyMemberFriend"`
 }
+
+type CallbackBeforeMemberJoinGroupReq struct {
+	CallbackCommand string `json:"callbackCommand"`
+	OperationID     string `json:"operationID"`
+	GroupID         string `json:"groupID"`
+	UserID          string `json:"userID"`
+	Ex              string `json:"ex"`
+	GroupEx         string `json:"groupEx"`
+}
+
+type CallbackBeforeMemberJoinGroupResp struct {
+	*CommonCallbackResp
+	NickName    *string `json:"nickName"`
+	FaceURL     *string `json:"faceURL"`
+	RoleLevel   *int32  `json:"roleLevel"`
+	MuteEndTime *int64  `json:"muteEndTime"`
+	Ex          *string `json:"ex"`
+}

pkg/cms_api_struct/admin.go

@@ -17,6 +17,17 @@ type AdminLoginResponse struct {
 	FaceURL  string `json:"faceURL"`
 }
 
+type GetUserTokenRequest struct {
+	UserID      string `json:"userID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+	PlatFormID  int32  `json:"platformID" binding:"required"`
+}
+
+type GetUserTokenResponse struct {
+	Token   string `json:"token"`
+	ExpTime int64  `json:"expTime"`
+}
+
 type AddUserRegisterAddFriendIDListRequest struct {
 	OperationID string   `json:"operationID" binding:"required"`
 	UserIDList  []string `json:"userIDList" binding:"required"`

pkg/common/config/config.go

@@ -291,6 +291,7 @@ type config struct {
 		CallbackBeforeSuperGroupOnlinePush callBackConfig `yaml:"callbackSuperGroupOnlinePush"`
 		CallbackBeforeAddFriend            callBackConfig `yaml:"callbackBeforeAddFriend"`
 		CallbackBeforeCreateGroup          callBackConfig `yaml:"callbackBeforeCreateGroup"`
+		CallbackBeforeMemberJoinGroup      callBackConfig `yaml:"callbackBeforeMemberJoinGroup"`
 	} `yaml:"callback"`
 	Notification struct {
 		///////////////////////group/////////////////////////////

pkg/common/constant/constant.go

@@ -196,19 +196,20 @@ const (
 	VerificationCodeForResetSuffix    = "_forReset"
 
 	//callbackCommand
-	CallbackBeforeSendSingleMsgCommand  = "callbackBeforeSendSingleMsgCommand"
-	CallbackAfterSendSingleMsgCommand   = "callbackAfterSendSingleMsgCommand"
-	CallbackBeforeSendGroupMsgCommand   = "callbackBeforeSendGroupMsgCommand"
-	CallbackAfterSendGroupMsgCommand    = "callbackAfterSendGroupMsgCommand"
-	CallbackMsgModifyCommand            = "callbackMsgModifyCommand"
-	CallbackUserOnlineCommand           = "callbackUserOnlineCommand"
-	CallbackUserOfflineCommand          = "callbackUserOfflineCommand"
-	CallbackUserKickOffCommand          = "callbackUserKickOffCommand"
-	CallbackOfflinePushCommand          = "callbackOfflinePushCommand"
-	CallbackOnlinePushCommand           = "callbackOnlinePushCommand"
-	CallbackSuperGroupOnlinePushCommand = "callbackSuperGroupOnlinePushCommand"
-	CallbackBeforeAddFriendCommand      = "callbackBeforeAddFriendCommand"
-	CallbackBeforeCreateGroupCommand    = "callbackBeforeCreateGroup"
+	CallbackBeforeSendSingleMsgCommand   = "callbackBeforeSendSingleMsgCommand"
+	CallbackAfterSendSingleMsgCommand    = "callbackAfterSendSingleMsgCommand"
+	CallbackBeforeSendGroupMsgCommand    = "callbackBeforeSendGroupMsgCommand"
+	CallbackAfterSendGroupMsgCommand     = "callbackAfterSendGroupMsgCommand"
+	CallbackMsgModifyCommand             = "callbackMsgModifyCommand"
+	CallbackUserOnlineCommand            = "callbackUserOnlineCommand"
+	CallbackUserOfflineCommand           = "callbackUserOfflineCommand"
+	CallbackUserKickOffCommand           = "callbackUserKickOffCommand"
+	CallbackOfflinePushCommand           = "callbackOfflinePushCommand"
+	CallbackOnlinePushCommand            = "callbackOnlinePushCommand"
+	CallbackSuperGroupOnlinePushCommand  = "callbackSuperGroupOnlinePushCommand"
+	CallbackBeforeAddFriendCommand       = "callbackBeforeAddFriendCommand"
+	CallbackBeforeCreateGroupCommand     = "callbackBeforeCreateGroupCommand"
+	CallbackBeforeMemberJoinGroupCommand = "callbackBeforeMemberJoinGroupCommand"
 
 	//callback actionCode
 	ActionAllow     = 0

pkg/common/constant/platform_number_id_to_name.go

@@ -14,6 +14,7 @@ const (
 	LinuxPlatformID      = 7
 	AndroidPadPlatformID = 8
 	IPadPlatformID       = 9
+	AdminPlatformID      = 10
 
 	//Platform string match to Platform ID
 	IOSPlatformStr        = "IOS"
@@ -25,6 +26,7 @@ const (
 	LinuxPlatformStr      = "Linux"
 	AndroidPadPlatformStr = "APad"
 	IPadPlatformStr       = "IPad"
+	AdminPlatformStr      = "Admin"
 
 	//terminal types
 	TerminalPC     = "PC"
@@ -41,6 +43,7 @@ var PlatformID2Name = map[int]string{
 	LinuxPlatformID:      LinuxPlatformStr,
 	AndroidPadPlatformID: AndroidPadPlatformStr,
 	IPadPlatformID:       IPadPlatformStr,
+	AdminPlatformID:      AdminPlatformStr,
 }
 var PlatformName2ID = map[string]int{
 	IOSPlatformStr:        IOSPlatformID,
@@ -52,6 +55,7 @@ var PlatformName2ID = map[string]int{
 	LinuxPlatformStr:      LinuxPlatformID,
 	AndroidPadPlatformStr: AndroidPadPlatformID,
 	IPadPlatformStr:       IPadPlatformID,
+	AdminPlatformStr:      AdminPlatformID,
 }
 var Platform2class = map[string]string{
 	IOSPlatformStr:     TerminalMobile,

pkg/proto/admin_cms/admin_cms.proto

@@ -23,6 +23,18 @@ message AdminLoginResp {
     CommonResp commonResp = 4;
 }
 
+message GetUserTokenReq {
+  string operationID = 1;
+  string userID = 2;
+  int32 platformID = 3;
+}
+
+message GetUserTokenResp {
+  CommonResp commonResp = 1;
+  string token = 2;
+  int64 expTime = 3;
+}
+
 message AddUserRegisterAddFriendIDListReq {
     string operationID = 1;
     repeated string userIDList = 2;
@@ -328,6 +340,7 @@ message GetUserIDByEmailAndPhoneNumberResp{
 
 service adminCMS {
     rpc AdminLogin(AdminLoginReq) returns(AdminLoginResp);
+
     rpc AddUserRegisterAddFriendIDList(AddUserRegisterAddFriendIDListReq) returns(AddUserRegisterAddFriendIDListResp);
     rpc ReduceUserRegisterAddFriendIDList(ReduceUserRegisterAddFriendIDListReq) returns(ReduceUserRegisterAddFriendIDListResp);
     rpc GetUserRegisterAddFriendIDList(GetUserRegisterAddFriendIDListReq) returns(GetUserRegisterAddFriendIDListResp);
@@ -357,4 +370,6 @@ service adminCMS {
     rpc GetUserFriends(GetUserFriendsReq) returns(GetUserFriendsResp);
 
     rpc GetUserIDByEmailAndPhoneNumber(GetUserIDByEmailAndPhoneNumberReq) returns(GetUserIDByEmailAndPhoneNumberResp);
+
+    rpc GetUserToken(GetUserTokenReq) returns(GetUserTokenResp);
 }