add callback and fix cache

config/config.yaml

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

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/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,8 @@ func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) cbApi.CommonCallback
 	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), req.String())
 	commonCallbackReq := &cbApi.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
+		GroupInfo:       *req.GroupInfo,
+		InitMemberList:  req.InitMemberList,
 	}
 	resp := &cbApi.CallbackBeforeCreateGroupResp{
 		CommonCallbackResp: &callbackResp,
@@ -41,7 +44,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 +71,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 +79,48 @@ 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,
+		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)
-			err = imdb.InsertIntoGroupMember(groupMember)
+			callbackResp := CallbackBeforeMemberJoinGroup(req.OperationID, &groupMember, groupInfo.Ex)
-			if err != nil {
+			if callbackResp.ErrCode != 0 {
-				log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
+				log.NewError(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg resp: ", callbackResp)
-				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 callbackResp.ActionCode != constant.ActionAllow {
-			if etcdConn == nil {
+				if callbackResp.ErrCode == 0 {
-				errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
+					callbackResp.ErrCode = 201
-				log.NewError(req.OperationID, errMsg)
+				}
-				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrInternal.ErrCode, ErrMsg: constant.ErrInternal.ErrMsg}}, nil
+				log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "callbackBeforeSendSingleMsg result", "end rpc and return", callbackResp)
-			}
+				return &pbGroup.JoinGroupResp{
-			cacheClient := pbCache.NewCacheClient(etcdConn)
+					CommonResp: &pbGroup.CommonResp{
-			cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
+						ErrCode: int32(callbackResp.ErrCode),
-				GroupID:     req.GroupID,
+						ErrMsg:  callbackResp.ErrMsg,
-				OperationID: req.OperationID,
+					},
-			})
+				}, nil
-			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())
+			if err := s.DelGroupAndUserCache(req.OperationID, req.GroupID, []string{req.OpUserID}); err != nil {
-				return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, 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 = rocksCache.DelJoinedGroupIDListFromCache(req.OpUserID)
+
+			err = imdb.InsertIntoGroupMember(groupMember)
 			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+				log.NewError(req.OperationID, "InsertIntoGroupMember failed ", err.Error(), groupMember)
-			}
+				return &pbGroup.JoinGroupResp{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 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)
 		}
@@ -1259,16 +1212,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 +1291,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 +1315,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 +1460,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 +1520,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 +1545,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 +1559,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 +1603,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 +1615,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 +1649,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 +1667,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 +1678,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 +1692,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 +1729,17 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
 	} else {
 		groupMemberInfo.Nickname = req.Nickname
 	}
+
+	if err := rocksCache.DelGroupInfoFromCache(req.GroupID); 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 +1748,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.DelGroupInfoFromCache(req.GroupID); 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 +1778,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 +1816,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
+}

pkg/call_back_struct/group.go

@@ -1,12 +1,14 @@
 package call_back_struct
 
 import (
+	"Open_IM/pkg/proto/group"
 	commonPb "Open_IM/pkg/proto/sdk_ws"
 )
 
 type CallbackBeforeCreateGroupReq struct {
 	CallbackCommand string `json:"callbackCommand"`
 	commonPb.GroupInfo
+	InitMemberList []*group.GroupAddMemberInfo `json:"initMemberList"`
 }
 
 type CallbackBeforeCreateGroupResp struct {
@@ -25,3 +27,20 @@ type CallbackBeforeCreateGroupResp struct {
 	LookMemberInfo    *int32  `json:"lookMemberInfo"`
 	ApplyMemberFriend *int32  `json:"applyMemberFriend"`
 }
+
+type CallbackBeforeMemberJoinGroupReq struct {
+	CallbackCommand string `json:"callbackCommand"`
+	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/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"
+	CallbackBeforeSendSingleMsgCommand   = "callbackBeforeSendSingleMsgCommand"
-	CallbackAfterSendSingleMsgCommand   = "callbackAfterSendSingleMsgCommand"
+	CallbackAfterSendSingleMsgCommand    = "callbackAfterSendSingleMsgCommand"
-	CallbackBeforeSendGroupMsgCommand   = "callbackBeforeSendGroupMsgCommand"
+	CallbackBeforeSendGroupMsgCommand    = "callbackBeforeSendGroupMsgCommand"
-	CallbackAfterSendGroupMsgCommand    = "callbackAfterSendGroupMsgCommand"
+	CallbackAfterSendGroupMsgCommand     = "callbackAfterSendGroupMsgCommand"
-	CallbackMsgModifyCommand            = "callbackMsgModifyCommand"
+	CallbackMsgModifyCommand             = "callbackMsgModifyCommand"
-	CallbackUserOnlineCommand           = "callbackUserOnlineCommand"
+	CallbackUserOnlineCommand            = "callbackUserOnlineCommand"
-	CallbackUserOfflineCommand          = "callbackUserOfflineCommand"
+	CallbackUserOfflineCommand           = "callbackUserOfflineCommand"
-	CallbackUserKickOffCommand          = "callbackUserKickOffCommand"
+	CallbackUserKickOffCommand           = "callbackUserKickOffCommand"
-	CallbackOfflinePushCommand          = "callbackOfflinePushCommand"
+	CallbackOfflinePushCommand           = "callbackOfflinePushCommand"
-	CallbackOnlinePushCommand           = "callbackOnlinePushCommand"
+	CallbackOnlinePushCommand            = "callbackOnlinePushCommand"
-	CallbackSuperGroupOnlinePushCommand = "callbackSuperGroupOnlinePushCommand"
+	CallbackSuperGroupOnlinePushCommand  = "callbackSuperGroupOnlinePushCommand"
-	CallbackBeforeAddFriendCommand      = "callbackBeforeAddFriendCommand"
+	CallbackBeforeAddFriendCommand       = "callbackBeforeAddFriendCommand"
-	CallbackBeforeCreateGroupCommand    = "callbackBeforeCreateGroup"
+	CallbackBeforeCreateGroupCommand     = "callbackBeforeCreateGroupCommand"
+	CallbackBeforeMemberJoinGroupCommand = "callbackBeforeMemberJoinGroupCommand"
 
 	//callback actionCode
 	ActionAllow     = 0