diff --git a/internal/msggateway/client.go b/internal/msggateway/client.go
index 2c2192e53..46da524d3 100644
--- a/internal/msggateway/client.go
+++ b/internal/msggateway/client.go
@@ -30,7 +30,6 @@ import (
 	"github.com/openimsdk/tools/errs"
 	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
-	"github.com/openimsdk/tools/utils/stringutil"
 )
 
 var (
@@ -85,7 +84,7 @@ type Client struct {
 func (c *Client) ResetClient(ctx *UserConnContext, conn ClientConn, longConnServer LongConnServer) {
 	c.w = new(sync.Mutex)
 	c.conn = conn
-	c.PlatformID = stringutil.StringToInt(ctx.GetPlatformID())
+	c.PlatformID = ctx.GetPlatformID()
 	c.IsCompress = ctx.GetCompression()
 	c.IsBackground = ctx.GetBackground()
 	c.UserID = ctx.GetUserID()
diff --git a/internal/msggateway/context.go b/internal/msggateway/context.go
index d73a96df4..6883c22a3 100644
--- a/internal/msggateway/context.go
+++ b/internal/msggateway/context.go
@@ -15,18 +15,31 @@
 package msggateway
 
 import (
-	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+	"encoding/base64"
+	"encoding/json"
 	"net/http"
 	"net/url"
 	"strconv"
 	"time"
 
+	"github.com/openimsdk/open-im-server/v3/pkg/common/servererrs"
+
 	"github.com/openimsdk/protocol/constant"
 	"github.com/openimsdk/tools/utils/encrypt"
-	"github.com/openimsdk/tools/utils/stringutil"
 	"github.com/openimsdk/tools/utils/timeutil"
 )
 
+type UserConnContextInfo struct {
+	Token        string `json:"token"`
+	UserID       string `json:"userID"`
+	PlatformID   int    `json:"platformID"`
+	OperationID  string `json:"operationID"`
+	Compression  string `json:"compression"`
+	SDKType      string `json:"sdkType"`
+	SendResponse bool   `json:"sendResponse"`
+	Background   bool   `json:"background"`
+}
+
 type UserConnContext struct {
 	RespWriter http.ResponseWriter
 	Req        *http.Request
@@ -34,6 +47,7 @@ type UserConnContext struct {
 	Method     string
 	RemoteAddr string
 	ConnID     string
+	info       *UserConnContextInfo
 }
 
 func (c *UserConnContext) Deadline() (deadline time.Time, ok bool) {
@@ -57,7 +71,7 @@ func (c *UserConnContext) Value(key any) any {
 	case constant.ConnID:
 		return c.GetConnID()
 	case constant.OpUserPlatform:
-		return constant.PlatformIDToName(stringutil.StringToInt(c.GetPlatformID()))
+		return c.GetPlatformID()
 	case constant.RemoteAddr:
 		return c.RemoteAddr
 	default:
@@ -82,28 +96,89 @@ func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnCont
 
 func newTempContext() *UserConnContext {
 	return &UserConnContext{
-		Req: &http.Request{URL: &url.URL{}},
+		Req:  &http.Request{URL: &url.URL{}},
+		info: &UserConnContextInfo{},
 	}
 }
 
-func (c *UserConnContext) GetRemoteAddr() string {
-	return c.RemoteAddr
+func (c *UserConnContext) ParseEssentialArgs() error {
+	query := c.Req.URL.Query()
+	if data := query.Get("v"); data != "" {
+		return c.parseByJson(data)
+	} else {
+		return c.parseByQuery(query, c.Req.Header)
+	}
 }
 
-func (c *UserConnContext) Query(key string) (string, bool) {
-	var value string
-	if value = c.Req.URL.Query().Get(key); value == "" {
-		return value, false
+func (c *UserConnContext) parseByQuery(query url.Values, header http.Header) error {
+	info := UserConnContextInfo{
+		Token:       query.Get(Token),
+		UserID:      query.Get(WsUserID),
+		OperationID: query.Get(OperationID),
+		Compression: query.Get(Compression),
+		SDKType:     query.Get(SDKType),
 	}
-	return value, true
+	platformID, err := strconv.Atoi(query.Get(PlatformID))
+	if err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("platformID is not int")
+	}
+	info.PlatformID = platformID
+	if val := query.Get(SendResponse); val != "" {
+		ok, err := strconv.ParseBool(val)
+		if err != nil {
+			return servererrs.ErrConnArgsErr.WrapMsg("isMsgResp is not bool")
+		}
+		info.SendResponse = ok
+	}
+	if info.Compression == "" {
+		info.Compression = header.Get(Compression)
+	}
+	background, err := strconv.ParseBool(query.Get(BackgroundStatus))
+	if err != nil {
+		return err
+	}
+	info.Background = background
+	return c.checkInfo(&info)
 }
 
-func (c *UserConnContext) GetHeader(key string) (string, bool) {
-	var value string
-	if value = c.Req.Header.Get(key); value == "" {
-		return value, false
+func (c *UserConnContext) parseByJson(data string) error {
+	reqInfo, err := base64.RawURLEncoding.DecodeString(data)
+	if err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("data is not base64")
+	}
+	var info UserConnContextInfo
+	if err := json.Unmarshal(reqInfo, &info); err != nil {
+		return servererrs.ErrConnArgsErr.WrapMsg("data is not json", "info", err.Error())
 	}
-	return value, true
+	return c.checkInfo(&info)
+}
+
+func (c *UserConnContext) checkInfo(info *UserConnContextInfo) error {
+	if info.OperationID == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("operationID is empty")
+	}
+	if info.Token == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("token is empty")
+	}
+	if info.UserID == "" {
+		return servererrs.ErrConnArgsErr.WrapMsg("sendID is empty")
+	}
+	if _, ok := constant.PlatformID2Name[info.PlatformID]; !ok {
+		return servererrs.ErrConnArgsErr.WrapMsg("platformID is invalid")
+	}
+	switch info.SDKType {
+	case "":
+		info.SDKType = GoSDK
+	case GoSDK, JsSDK:
+	default:
+		return servererrs.ErrConnArgsErr.WrapMsg("sdkType is invalid")
+	}
+	c.info = info
+	return nil
+}
+
+func (c *UserConnContext) GetRemoteAddr() string {
+	return c.RemoteAddr
 }
 
 func (c *UserConnContext) SetHeader(key, value string) {
@@ -119,93 +194,69 @@ func (c *UserConnContext) GetConnID() string {
 }
 
 func (c *UserConnContext) GetUserID() string {
-	return c.Req.URL.Query().Get(WsUserID)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.UserID
 }
 
-func (c *UserConnContext) GetPlatformID() string {
-	return c.Req.URL.Query().Get(PlatformID)
+func (c *UserConnContext) GetPlatformID() int {
+	if c == nil || c.info == nil {
+		return 0
+	}
+	return c.info.PlatformID
 }
 
 func (c *UserConnContext) GetOperationID() string {
-	return c.Req.URL.Query().Get(OperationID)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.OperationID
 }
 
 func (c *UserConnContext) SetOperationID(operationID string) {
-	values := c.Req.URL.Query()
-	values.Set(OperationID, operationID)
-	c.Req.URL.RawQuery = values.Encode()
+	if c.info == nil {
+		c.info = &UserConnContextInfo{}
+	}
+	c.info.OperationID = operationID
 }
 
 func (c *UserConnContext) GetToken() string {
-	return c.Req.URL.Query().Get(Token)
+	if c == nil || c.info == nil {
+		return ""
+	}
+	return c.info.Token
 }
 
 func (c *UserConnContext) GetCompression() bool {
-	compression, exists := c.Query(Compression)
-	if exists && compression == GzipCompressionProtocol {
-		return true
-	} else {
-		compression, exists := c.GetHeader(Compression)
-		if exists && compression == GzipCompressionProtocol {
-			return true
-		}
-	}
-	return false
+	return c != nil && c.info != nil && c.info.Compression == GzipCompressionProtocol
 }
 
 func (c *UserConnContext) GetSDKType() string {
-	sdkType := c.Req.URL.Query().Get(SDKType)
-	if sdkType == "" {
-		sdkType = GoSDK
+	if c == nil || c.info == nil {
+		return GoSDK
+	}
+	switch c.info.SDKType {
+	case "", GoSDK:
+		return GoSDK
+	case JsSDK:
+		return JsSDK
+	default:
+		return ""
 	}
-	return sdkType
 }
 
 func (c *UserConnContext) ShouldSendResp() bool {
-	errResp, exists := c.Query(SendResponse)
-	if exists {
-		b, err := strconv.ParseBool(errResp)
-		if err != nil {
-			return false
-		} else {
-			return b
-		}
-	}
-	return false
+	return c != nil && c.info != nil && c.info.SendResponse
 }
 
 func (c *UserConnContext) SetToken(token string) {
-	c.Req.URL.RawQuery = Token + "=" + token
+	if c.info == nil {
+		c.info = &UserConnContextInfo{}
+	}
+	c.info.Token = token
 }
 
 func (c *UserConnContext) GetBackground() bool {
-	b, err := strconv.ParseBool(c.Req.URL.Query().Get(BackgroundStatus))
-	if err != nil {
-		return false
-	}
-	return b
-}
-func (c *UserConnContext) ParseEssentialArgs() error {
-	_, exists := c.Query(Token)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("token is empty")
-	}
-	_, exists = c.Query(WsUserID)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("sendID is empty")
-	}
-	platformIDStr, exists := c.Query(PlatformID)
-	if !exists {
-		return servererrs.ErrConnArgsErr.WrapMsg("platformID is empty")
-	}
-	_, err := strconv.Atoi(platformIDStr)
-	if err != nil {
-		return servererrs.ErrConnArgsErr.WrapMsg("platformID is not int")
-	}
-	switch sdkType, _ := c.Query(SDKType); sdkType {
-	case "", GoSDK, JsSDK:
-	default:
-		return servererrs.ErrConnArgsErr.WrapMsg("sdkType is not go or js")
-	}
-	return nil
+	return c != nil && c.info != nil && c.info.Background
 }
diff --git a/internal/msggateway/ws_server.go b/internal/msggateway/ws_server.go
index fe729d5fb..404751df3 100644
--- a/internal/msggateway/ws_server.go
+++ b/internal/msggateway/ws_server.go
@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"strconv"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -30,6 +29,8 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
+var wsSuccessResponse, _ = json.Marshal(&apiresp.ApiResponse{})
+
 type LongConnServer interface {
 	Run(done chan error) error
 	wsHandler(w http.ResponseWriter, r *http.Request)
@@ -448,11 +449,11 @@ func (ws *WsServer) unregisterClient(client *Client) {
 // validateRespWithRequest checks if the response matches the expected userID and platformID.
 func (ws *WsServer) validateRespWithRequest(ctx *UserConnContext, resp *pbAuth.ParseTokenResp) error {
 	userID := ctx.GetUserID()
-	platformID := stringutil.StringToInt32(ctx.GetPlatformID())
+	platformID := ctx.GetPlatformID()
 	if resp.UserID != userID {
 		return servererrs.ErrTokenInvalid.WrapMsg(fmt.Sprintf("token uid %s != userID %s", resp.UserID, userID))
 	}
-	if resp.PlatformID != platformID {
+	if int(resp.PlatformID) != platformID {
 		return servererrs.ErrTokenInvalid.WrapMsg(fmt.Sprintf("token platform %d != platformID %d", resp.PlatformID, platformID))
 	}
 	return nil
@@ -519,10 +520,16 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
 		log.ZWarn(connContext, "websocket upgrade failed", err)
 		return
 	}
+	if connContext.ShouldSendResp() {
+		if err := conn.WriteMessage(websocket.TextMessage, wsSuccessResponse); err != nil {
+			log.ZWarn(connContext, "WriteMessage first response", err)
+			return
+		}
+	}
 	log.ZDebug(connContext, "new conn", "token", connContext.GetToken())
 
 	var pingInterval time.Duration
-	if connContext.GetPlatformID() == strconv.Itoa(constant.WebPlatformID) {
+	if connContext.GetPlatformID() == constant.WebPlatformID {
 		pingInterval = pingPeriod
 	}
 
diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go
index 910df3c26..f4e9f0c78 100644
--- a/internal/rpc/group/group.go
+++ b/internal/rpc/group/group.go
@@ -131,8 +131,8 @@ func Start(ctx context.Context, config *Config, client discovery.SvcDiscoveryReg
 	return nil
 }
 
-func (g *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgroup.NotificationUserInfoUpdateReq) (*pbgroup.NotificationUserInfoUpdateResp, error) {
-	members, err := g.db.FindGroupMemberUser(ctx, nil, req.UserID)
+func (s *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgroup.NotificationUserInfoUpdateReq) (*pbgroup.NotificationUserInfoUpdateResp, error) {
+	members, err := s.db.FindGroupMemberUser(ctx, nil, req.UserID)
 	if err != nil {
 		return nil, err
 	}
@@ -144,22 +144,22 @@ func (g *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgro
 		groupIDs = append(groupIDs, member.GroupID)
 	}
 	for _, groupID := range groupIDs {
-		if err := g.db.MemberGroupIncrVersion(ctx, groupID, []string{req.UserID}, model.VersionStateUpdate); err != nil {
+		if err := s.db.MemberGroupIncrVersion(ctx, groupID, []string{req.UserID}, model.VersionStateUpdate); err != nil {
 			return nil, err
 		}
 	}
 	for _, groupID := range groupIDs {
-		g.notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID)
+		s.notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID)
 	}
-	if err = g.db.DeleteGroupMemberHash(ctx, groupIDs); err != nil {
+	if err = s.db.DeleteGroupMemberHash(ctx, groupIDs); err != nil {
 		return nil, err
 	}
 	return &pbgroup.NotificationUserInfoUpdateResp{}, nil
 }
 
-func (g *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
-		groupMember, err := g.db.TakeGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
+func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
+		groupMember, err := s.db.TakeGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return err
 		}
@@ -170,16 +170,16 @@ func (g *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
 	return nil
 }
 
-func (g *groupServer) IsNotFound(err error) bool {
+func (s *groupServer) IsNotFound(err error) bool {
 	return errs.ErrRecordNotFound.Is(specialerror.ErrCode(errs.Unwrap(err)))
 }
 
-func (g *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
+func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 	if *groupID != "" {
-		_, err := g.db.TakeGroup(ctx, *groupID)
+		_, err := s.db.TakeGroup(ctx, *groupID)
 		if err == nil {
 			return servererrs.ErrGroupIDExisted.WrapMsg("group id existed " + *groupID)
-		} else if g.IsNotFound(err) {
+		} else if s.IsNotFound(err) {
 			return nil
 		} else {
 			return err
@@ -190,10 +190,10 @@ func (g *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 		bi := big.NewInt(0)
 		bi.SetString(id[0:8], 16)
 		id = bi.String()
-		_, err := g.db.TakeGroup(ctx, id)
+		_, err := s.db.TakeGroup(ctx, id)
 		if err == nil {
 			continue
-		} else if g.IsNotFound(err) {
+		} else if s.IsNotFound(err) {
 			*groupID = id
 			return nil
 		} else {
@@ -203,14 +203,14 @@ func (g *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 	return servererrs.ErrData.WrapMsg("group id gen error")
 }
 
-func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupReq) (*pbgroup.CreateGroupResp, error) {
+func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupReq) (*pbgroup.CreateGroupResp, error) {
 	if req.GroupInfo.GroupType != constant.WorkingGroup {
 		return nil, errs.ErrArgs.WrapMsg(fmt.Sprintf("group type only supports %d", constant.WorkingGroup))
 	}
 	if req.OwnerUserID == "" {
 		return nil, errs.ErrArgs.WrapMsg("no group owner")
 	}
-	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, g.config.Share.IMAdminUserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.OwnerUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
 	userIDs := append(append(req.MemberUserIDs, req.AdminUserIDs...), req.OwnerUserID)
@@ -223,7 +223,7 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, errs.ErrArgs.WrapMsg("group member repeated")
 	}
 
-	userMap, err := g.userClient.GetUsersInfoMap(ctx, userIDs)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -232,13 +232,13 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, servererrs.ErrUserIDNotFound.WrapMsg("user not found")
 	}
 
-	if err := g.webhookBeforeCreateGroup(ctx, &g.config.WebhooksConfig.BeforeCreateGroup, req); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeCreateGroup(ctx, &s.config.WebhooksConfig.BeforeCreateGroup, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
 	var groupMembers []*model.GroupMember
 	group := convert.Pb2DBGroupInfo(req.GroupInfo)
-	if err := g.GenGroupID(ctx, &group.GroupID); err != nil {
+	if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
 		return nil, err
 	}
 
@@ -267,11 +267,11 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		joinGroupFunc(userID, constant.GroupOrdinaryUsers)
 	}
 
-	if err := g.webhookBeforeMembersJoinGroup(ctx, &g.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeMembersJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
-	if err := g.db.CreateGroup(ctx, []*model.Group{group}, groupMembers); err != nil {
+	if err := s.db.CreateGroup(ctx, []*model.Group{group}, groupMembers); err != nil {
 		return nil, err
 	}
 	resp := &pbgroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
@@ -281,21 +281,21 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 	tips := &sdkws.GroupCreatedTips{
 		Group:          resp.GroupInfo,
 		OperationTime:  group.CreateTime.UnixMilli(),
-		GroupOwnerUser: g.groupMemberDB2PB(groupMembers[0], userMap[groupMembers[0].UserID].AppMangerLevel),
+		GroupOwnerUser: s.groupMemberDB2PB(groupMembers[0], userMap[groupMembers[0].UserID].AppMangerLevel),
 	}
 	for _, member := range groupMembers {
 		member.Nickname = userMap[member.UserID].Nickname
-		tips.MemberList = append(tips.MemberList, g.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel))
+		tips.MemberList = append(tips.MemberList, s.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel))
 		if member.UserID == opUserID {
-			tips.OpUser = g.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel)
+			tips.OpUser = s.groupMemberDB2PB(member, userMap[member.UserID].AppMangerLevel)
 			break
 		}
 	}
-	g.notification.GroupCreatedNotification(ctx, tips, req.SendMessage)
+	s.notification.GroupCreatedNotification(ctx, tips, req.SendMessage)
 
 	if req.GroupInfo.Notification != "" {
 		notificationFlag := true
-		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{
+		s.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{
 			Group:  tips.Group,
 			OpUser: tips.OpUser,
 		}, &notificationFlag)
@@ -308,16 +308,16 @@ func (g *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		AdminUserIDs:  req.AdminUserIDs,
 	}
 
-	g.webhookAfterCreateGroup(ctx, &g.config.WebhooksConfig.AfterCreateGroup, reqCallBackAfter)
+	s.webhookAfterCreateGroup(ctx, &s.config.WebhooksConfig.AfterCreateGroup, reqCallBackAfter)
 
 	return resp, nil
 }
 
-func (g *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJoinedGroupListReq) (*pbgroup.GetJoinedGroupListResp, error) {
-	if err := authverify.CheckAccessV3(ctx, req.FromUserID, g.config.Share.IMAdminUserID); err != nil {
+func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJoinedGroupListReq) (*pbgroup.GetJoinedGroupListResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.FromUserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
-	total, members, err := g.db.PageGetJoinGroup(ctx, req.FromUserID, req.Pagination)
+	total, members, err := s.db.PageGetJoinGroup(ctx, req.FromUserID, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -329,19 +329,19 @@ func (g *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJo
 	groupIDs := datautil.Slice(members, func(e *model.GroupMember) string {
 		return e.GroupID
 	})
-	groups, err := g.db.FindGroup(ctx, groupIDs)
+	groups, err := s.db.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNum, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	owners, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	ownerMap := datautil.SliceToMap(owners, func(e *model.GroupMember) string {
@@ -359,14 +359,14 @@ func (g *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJo
 	return &resp, nil
 }
 
-func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.InviteUserToGroupReq) (*pbgroup.InviteUserToGroupResp, error) {
+func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.InviteUserToGroupReq) (*pbgroup.InviteUserToGroupResp, error) {
 	if len(req.InvitedUserIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("user empty")
 	}
 	if datautil.Duplicate(req.InvitedUserIDs) {
 		return nil, errs.ErrArgs.WrapMsg("userID duplicate")
 	}
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -375,7 +375,7 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		return nil, servererrs.ErrDismissedAlready.WrapMsg("group dismissed checking group status found it dismissed")
 	}
 
-	userMap, err := g.userClient.GetUsersInfoMap(ctx, req.InvitedUserIDs)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.InvitedUserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -386,26 +386,26 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 
 	var groupMember *model.GroupMember
 	var opUserID string
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		opUserID = mcontext.GetOpUserID(ctx)
 		var err error
-		groupMember, err = g.db.TakeGroupMember(ctx, req.GroupID, opUserID)
+		groupMember, err = s.db.TakeGroupMember(ctx, req.GroupID, opUserID)
 		if err != nil {
 			return nil, err
 		}
-		if err := g.PopulateGroupMember(ctx, groupMember); err != nil {
+		if err := s.PopulateGroupMember(ctx, groupMember); err != nil {
 			return nil, err
 		}
 	} else {
 		opUserID = mcontext.GetOpUserID(ctx)
 	}
 
-	if err := g.webhookBeforeInviteUserToGroup(ctx, &g.config.WebhooksConfig.BeforeInviteUserToGroup, req); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeInviteUserToGroup(ctx, &s.config.WebhooksConfig.BeforeInviteUserToGroup, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
 	if group.NeedVerification == constant.AllNeedVerification {
-		if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+		if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 			if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
 				var requests []*model.GroupRequest
 				for _, userID := range req.InvitedUserIDs {
@@ -418,11 +418,11 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 						HandledTime:   time.Unix(0, 0),
 					})
 				}
-				if err := g.db.CreateGroupRequest(ctx, requests); err != nil {
+				if err := s.db.CreateGroupRequest(ctx, requests); err != nil {
 					return nil, err
 				}
 				for _, request := range requests {
-					g.notification.JoinGroupApplicationNotification(ctx, &pbgroup.JoinGroupReq{
+					s.notification.JoinGroupApplicationNotification(ctx, &pbgroup.JoinGroupReq{
 						GroupID:       request.GroupID,
 						ReqMessage:    request.ReqMsg,
 						JoinSource:    request.JoinSource,
@@ -450,7 +450,7 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		groupMembers = append(groupMembers, member)
 	}
 
-	if err := g.webhookBeforeMembersJoinGroup(ctx, &g.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeMembersJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, groupMembers, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
@@ -462,7 +462,7 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 		}
 		currentMembers := groupMembers[start:end]
 
-		if err := g.db.CreateGroup(ctx, nil, currentMembers); err != nil {
+		if err := s.db.CreateGroup(ctx, nil, currentMembers); err != nil {
 			return nil, err
 		}
 
@@ -470,22 +470,22 @@ func (g *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 			return e.UserID
 		})
 
-		if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, req.SendMessage, opUserID, userIDs...); err != nil {
+		if err = s.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, req.SendMessage, opUserID, userIDs...); err != nil {
 			return nil, err
 		}
-		if err := g.setMemberJoinSeq(ctx, req.GroupID, userIDs); err != nil {
+		if err := s.setMemberJoinSeq(ctx, req.GroupID, userIDs); err != nil {
 			return nil, err
 		}
 	}
 	return &pbgroup.InviteUserToGroupResp{}, nil
 }
 
-func (g *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGroupAllMemberReq) (*pbgroup.GetGroupAllMemberResp, error) {
-	members, err := g.db.FindGroupMemberAll(ctx, req.GroupID)
+func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGroupAllMemberReq) (*pbgroup.GetGroupAllMemberResp, error) {
+	members, err := s.db.FindGroupMemberAll(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	var resp pbgroup.GetGroupAllMemberResp
@@ -495,12 +495,12 @@ func (g *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGro
 	return &resp, nil
 }
 
-func (g *groupServer) checkAdminOrInGroup(ctx context.Context, groupID string) error {
-	if authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+func (s *groupServer) checkAdminOrInGroup(ctx context.Context, groupID string) error {
+	if authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		return nil
 	}
 	opUserID := mcontext.GetOpUserID(ctx)
-	members, err := g.db.FindGroupMembers(ctx, groupID, []string{opUserID})
+	members, err := s.db.FindGroupMembers(ctx, groupID, []string{opUserID})
 	if err != nil {
 		return err
 	}
@@ -510,8 +510,8 @@ func (g *groupServer) checkAdminOrInGroup(ctx context.Context, groupID string) e
 	return nil
 }
 
-func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGroupMemberListReq) (*pbgroup.GetGroupMemberListResp, error) {
-	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGroupMemberListReq) (*pbgroup.GetGroupMemberListResp, error) {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
 	var (
@@ -520,14 +520,14 @@ func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGr
 		err     error
 	)
 	if req.Keyword == "" {
-		total, members, err = g.db.PageGetGroupMember(ctx, req.GroupID, req.Pagination)
+		total, members, err = s.db.PageGetGroupMember(ctx, req.GroupID, req.Pagination)
 	} else {
-		total, members, err = g.db.SearchGroupMember(ctx, req.GroupID, req.Keyword, req.Pagination)
+		total, members, err = s.db.SearchGroupMember(ctx, req.GroupID, req.Keyword, req.Pagination)
 	}
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	return &pbgroup.GetGroupMemberListResp{
@@ -536,8 +536,8 @@ func (g *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGr
 	}, nil
 }
 
-func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGroupMemberReq) (*pbgroup.KickGroupMemberResp, error) {
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGroupMemberReq) (*pbgroup.KickGroupMemberResp, error) {
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -551,7 +551,7 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	if datautil.Contain(opUserID, req.KickedUserIDs...) {
 		return nil, errs.ErrArgs.WrapMsg("opUserID in KickedUserIDs")
 	}
-	owner, err := g.db.TakeGroupOwner(ctx, req.GroupID)
+	owner, err := s.db.TakeGroupOwner(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -559,18 +559,18 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 		return nil, errs.ErrArgs.WrapMsg("ownerUID can not Kick")
 	}
 
-	members, err := g.db.FindGroupMembers(ctx, req.GroupID, append(req.KickedUserIDs, opUserID))
+	members, err := s.db.FindGroupMembers(ctx, req.GroupID, append(req.KickedUserIDs, opUserID))
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	memberMap := make(map[string]*model.GroupMember)
 	for i, member := range members {
 		memberMap[member.UserID] = members[i]
 	}
-	isAppManagerUid := authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID)
+	isAppManagerUid := authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID)
 	opMember := memberMap[opUserID]
 	for _, userID := range req.KickedUserIDs {
 		member, ok := memberMap[userID]
@@ -594,11 +594,11 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 			}
 		}
 	}
-	num, err := g.db.FindGroupMemberNum(ctx, req.GroupID)
+	num, err := s.db.FindGroupMemberNum(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	ownerUserIDs, err := g.db.GetGroupRoleLevelMemberIDs(ctx, req.GroupID, constant.GroupOwner)
+	ownerUserIDs, err := s.db.GetGroupRoleLevelMemberIDs(ctx, req.GroupID, constant.GroupOwner)
 	if err != nil {
 		return nil, err
 	}
@@ -606,7 +606,7 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	if len(ownerUserIDs) > 0 {
 		ownerUserID = ownerUserIDs[0]
 	}
-	if err := g.db.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
+	if err := s.db.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
 	tips := &sdkws.MemberKickedTips{
@@ -637,26 +637,26 @@ func (g *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	for _, userID := range req.KickedUserIDs {
 		tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMember(memberMap[userID]))
 	}
-	g.notification.MemberKickedNotification(ctx, tips, req.SendMessage)
-	if err := g.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
+	s.notification.MemberKickedNotification(ctx, tips, req.SendMessage)
+	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
-	g.webhookAfterKickGroupMember(ctx, &g.config.WebhooksConfig.AfterKickGroupMember, req)
+	s.webhookAfterKickGroupMember(ctx, &s.config.WebhooksConfig.AfterKickGroupMember, req)
 
 	return &pbgroup.KickGroupMemberResp{}, nil
 }
 
-func (g *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetGroupMembersInfoReq) (*pbgroup.GetGroupMembersInfoResp, error) {
+func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetGroupMembersInfoReq) (*pbgroup.GetGroupMembersInfoResp, error) {
 	if len(req.UserIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("userIDs empty")
 	}
 	if req.GroupID == "" {
 		return nil, errs.ErrArgs.WrapMsg("groupID empty")
 	}
-	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
-	members, err := g.getGroupMembersInfo(ctx, req.GroupID, req.UserIDs)
+	members, err := s.getGroupMembersInfo(ctx, req.GroupID, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -665,15 +665,15 @@ func (g *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetG
 	}, nil
 }
 
-func (g *groupServer) getGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
+func (s *groupServer) getGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]*sdkws.GroupMemberFullInfo, error) {
 	if len(userIDs) == 0 {
 		return nil, nil
 	}
-	members, err := g.db.FindGroupMembers(ctx, groupID, userIDs)
+	members, err := s.db.FindGroupMembers(ctx, groupID, userIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	return datautil.Slice(members, func(e *model.GroupMember) *sdkws.GroupMemberFullInfo {
@@ -682,21 +682,21 @@ func (g *groupServer) getGroupMembersInfo(ctx context.Context, groupID string, u
 }
 
 // GetGroupApplicationList handles functions that get a list of group requests.
-func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.GetGroupApplicationListReq) (*pbgroup.GetGroupApplicationListResp, error) {
+func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.GetGroupApplicationListReq) (*pbgroup.GetGroupApplicationListResp, error) {
 	var (
 		groupIDs []string
 		err      error
 	)
 	if len(req.GroupIDs) == 0 {
-		groupIDs, err = g.db.FindUserManagedGroupID(ctx, req.FromUserID)
+		groupIDs, err = s.db.FindUserManagedGroupID(ctx, req.FromUserID)
 		if err != nil {
 			return nil, err
 		}
 	} else {
 		req.GroupIDs = datautil.Distinct(req.GroupIDs)
-		if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+		if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 			for _, groupID := range req.GroupIDs {
-				if err := g.CheckGroupAdmin(ctx, groupID); err != nil {
+				if err := s.CheckGroupAdmin(ctx, groupID); err != nil {
 					return nil, err
 				}
 			}
@@ -710,7 +710,7 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
 		return int(e)
 	})
-	total, groupRequests, err := g.db.PageGroupRequest(ctx, groupIDs, handleResults, req.Pagination)
+	total, groupRequests, err := s.db.PageGroupRequest(ctx, groupIDs, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -724,11 +724,11 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 		userIDs = append(userIDs, gr.UserID)
 	}
 	userIDs = datautil.Distinct(userIDs)
-	userMap, err := g.userClient.GetUsersInfoMap(ctx, userIDs)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, userIDs)
 	if err != nil {
 		return nil, err
 	}
-	groups, err := g.db.FindGroup(ctx, datautil.Distinct(groupIDs))
+	groups, err := s.db.FindGroup(ctx, datautil.Distinct(groupIDs))
 	if err != nil {
 		return nil, err
 	}
@@ -738,15 +738,15 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 	if ids := datautil.Single(datautil.Keys(groupMap), groupIDs); len(ids) > 0 {
 		return nil, servererrs.ErrGroupIDNotFound.WrapMsg(strings.Join(ids, ","))
 	}
-	groupMemberNumMap, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNumMap, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	owners, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, owners...); err != nil {
+	if err := s.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
 	ownerMap := datautil.SliceToMap(owners, func(e *model.GroupMember) string {
@@ -762,11 +762,11 @@ func (g *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 	return resp, nil
 }
 
-func (g *groupServer) GetGroupsInfo(ctx context.Context, req *pbgroup.GetGroupsInfoReq) (*pbgroup.GetGroupsInfoResp, error) {
+func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbgroup.GetGroupsInfoReq) (*pbgroup.GetGroupsInfoResp, error) {
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("groupID is empty")
 	}
-	groups, err := g.getGroupsInfo(ctx, req.GroupIDs)
+	groups, err := s.getGroupsInfo(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -775,15 +775,15 @@ func (g *groupServer) GetGroupsInfo(ctx context.Context, req *pbgroup.GetGroupsI
 	}, nil
 }
 
-func (g *groupServer) GetGroupApplicationUnhandledCount(ctx context.Context, req *pbgroup.GetGroupApplicationUnhandledCountReq) (*pbgroup.GetGroupApplicationUnhandledCountResp, error) {
-	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+func (s *groupServer) GetGroupApplicationUnhandledCount(ctx context.Context, req *pbgroup.GetGroupApplicationUnhandledCountReq) (*pbgroup.GetGroupApplicationUnhandledCountResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
-	groupIDs, err := g.db.FindUserManagedGroupID(ctx, req.UserID)
+	groupIDs, err := s.db.FindUserManagedGroupID(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
-	count, err := g.db.GetGroupApplicationUnhandledCount(ctx, groupIDs, req.Time)
+	count, err := s.db.GetGroupApplicationUnhandledCount(ctx, groupIDs, req.Time)
 	if err != nil {
 		return nil, err
 	}
@@ -792,23 +792,23 @@ func (g *groupServer) GetGroupApplicationUnhandledCount(ctx context.Context, req
 	}, nil
 }
 
-func (g *groupServer) getGroupsInfo(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
+func (s *groupServer) getGroupsInfo(ctx context.Context, groupIDs []string) ([]*sdkws.GroupInfo, error) {
 	if len(groupIDs) == 0 {
 		return nil, nil
 	}
-	groups, err := g.db.FindGroup(ctx, groupIDs)
+	groups, err := s.db.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	groupMemberNumMap, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNumMap, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	owners, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, owners...); err != nil {
+	if err := s.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
 	ownerMap := datautil.SliceToMap(owners, func(e *model.GroupMember) string {
@@ -823,12 +823,12 @@ func (g *groupServer) getGroupsInfo(ctx context.Context, groupIDs []string) ([]*
 	}), nil
 }
 
-func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) (*pbgroup.GroupApplicationResponseResp, error) {
+func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) (*pbgroup.GroupApplicationResponseResp, error) {
 	if !datautil.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
 		return nil, errs.ErrArgs.WrapMsg("HandleResult unknown")
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
-		groupMember, err := g.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
+		groupMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -836,11 +836,11 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 			return nil, errs.ErrNoPermission.WrapMsg("no group owner or admin")
 		}
 	}
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	groupRequest, err := g.db.TakeGroupRequest(ctx, req.GroupID, req.FromUserID)
+	groupRequest, err := s.db.TakeGroupRequest(ctx, req.GroupID, req.FromUserID)
 	if err != nil {
 		return nil, err
 	}
@@ -848,12 +848,12 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 		return nil, servererrs.ErrGroupRequestHandled.WrapMsg("group request already processed")
 	}
 	var inGroup bool
-	if _, err := g.db.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
+	if _, err := s.db.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
 		inGroup = true // Already in group
-	} else if !g.IsNotFound(err) {
+	} else if !s.IsNotFound(err) {
 		return nil, err
 	}
-	if err := g.userClient.CheckUser(ctx, []string{req.FromUserID}); err != nil {
+	if err := s.userClient.CheckUser(ctx, []string{req.FromUserID}); err != nil {
 		return nil, err
 	}
 	var member *model.GroupMember
@@ -871,46 +871,46 @@ func (g *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 			OperatorUserID: mcontext.GetOpUserID(ctx),
 		}
 
-		if err := g.webhookBeforeMembersJoinGroup(ctx, &g.config.WebhooksConfig.BeforeMemberJoinGroup, []*model.GroupMember{member}, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+		if err := s.webhookBeforeMembersJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, []*model.GroupMember{member}, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
 			return nil, err
 		}
 	}
 	log.ZDebug(ctx, "GroupApplicationResponse", "inGroup", inGroup, "HandleResult", req.HandleResult, "member", member)
-	if err := g.db.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
+	if err := s.db.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
 		return nil, err
 	}
 	switch req.HandleResult {
 	case constant.GroupResponseAgree:
-		g.notification.GroupApplicationAcceptedNotification(ctx, req)
+		s.notification.GroupApplicationAcceptedNotification(ctx, req)
 		if member == nil {
 			log.ZDebug(ctx, "GroupApplicationResponse", "member is nil")
 		} else {
 			if groupRequest.InviterUserID == "" {
-				if err = g.notification.MemberEnterNotification(ctx, req.GroupID, req.FromUserID); err != nil {
+				if err = s.notification.MemberEnterNotification(ctx, req.GroupID, req.FromUserID); err != nil {
 					return nil, err
 				}
 			} else {
-				if err = g.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, nil, groupRequest.InviterUserID, req.FromUserID); err != nil {
+				if err = s.notification.GroupApplicationAgreeMemberEnterNotification(ctx, req.GroupID, nil, groupRequest.InviterUserID, req.FromUserID); err != nil {
 					return nil, err
 				}
 			}
-			if err := g.setMemberJoinSeq(ctx, req.GroupID, []string{req.FromUserID}); err != nil {
+			if err := s.setMemberJoinSeq(ctx, req.GroupID, []string{req.FromUserID}); err != nil {
 				return nil, err
 			}
 		}
 	case constant.GroupResponseRefuse:
-		g.notification.GroupApplicationRejectedNotification(ctx, req)
+		s.notification.GroupApplicationRejectedNotification(ctx, req)
 	}
 
 	return &pbgroup.GroupApplicationResponseResp{}, nil
 }
 
-func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (*pbgroup.JoinGroupResp, error) {
-	user, err := g.userClient.GetUserInfo(ctx, req.InviterUserID)
+func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (*pbgroup.JoinGroupResp, error) {
+	user, err := s.userClient.GetUserInfo(ctx, req.InviterUserID)
 	if err != nil {
 		return nil, err
 	}
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -926,14 +926,14 @@ func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 		Ex:         req.Ex,
 	}
 
-	if err := g.webhookBeforeApplyJoinGroup(ctx, &g.config.WebhooksConfig.BeforeApplyJoinGroup, reqCall); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeApplyJoinGroup(ctx, &s.config.WebhooksConfig.BeforeApplyJoinGroup, reqCall); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
-	_, err = g.db.TakeGroupMember(ctx, req.GroupID, req.InviterUserID)
+	_, err = s.db.TakeGroupMember(ctx, req.GroupID, req.InviterUserID)
 	if err == nil {
 		return nil, errs.ErrArgs.Wrap()
-	} else if !g.IsNotFound(err) && errs.Unwrap(err) != errs.ErrRecordNotFound {
+	} else if !s.IsNotFound(err) && errs.Unwrap(err) != errs.ErrRecordNotFound {
 		return nil, err
 	}
 	log.ZDebug(ctx, "JoinGroup.groupInfo", "group", group, "eq", group.NeedVerification == constant.Directly)
@@ -948,21 +948,21 @@ func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 			MuteEndTime:    time.UnixMilli(0),
 		}
 
-		if err := g.webhookBeforeMembersJoinGroup(ctx, &g.config.WebhooksConfig.BeforeMemberJoinGroup, []*model.GroupMember{groupMember}, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
+		if err := s.webhookBeforeMembersJoinGroup(ctx, &s.config.WebhooksConfig.BeforeMemberJoinGroup, []*model.GroupMember{groupMember}, group.GroupID, group.Ex); err != nil && err != servererrs.ErrCallbackContinue {
 			return nil, err
 		}
 
-		if err := g.db.CreateGroup(ctx, nil, []*model.GroupMember{groupMember}); err != nil {
+		if err := s.db.CreateGroup(ctx, nil, []*model.GroupMember{groupMember}); err != nil {
 			return nil, err
 		}
 
-		if err = g.notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID); err != nil {
+		if err = s.notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID); err != nil {
 			return nil, err
 		}
-		if err := g.setMemberJoinSeq(ctx, req.GroupID, []string{req.InviterUserID}); err != nil {
+		if err := s.setMemberJoinSeq(ctx, req.GroupID, []string{req.InviterUserID}); err != nil {
 			return nil, err
 		}
-		g.webhookAfterJoinGroup(ctx, &g.config.WebhooksConfig.AfterJoinGroup, req)
+		s.webhookAfterJoinGroup(ctx, &s.config.WebhooksConfig.AfterJoinGroup, req)
 
 		return &pbgroup.JoinGroupResp{}, nil
 	}
@@ -976,79 +976,79 @@ func (g *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
 		HandledTime: time.Unix(0, 0),
 		Ex:          req.Ex,
 	}
-	if err = g.db.CreateGroupRequest(ctx, []*model.GroupRequest{&groupRequest}); err != nil {
+	if err = s.db.CreateGroupRequest(ctx, []*model.GroupRequest{&groupRequest}); err != nil {
 		return nil, err
 	}
-	g.notification.JoinGroupApplicationNotification(ctx, req, &groupRequest)
+	s.notification.JoinGroupApplicationNotification(ctx, req, &groupRequest)
 	return &pbgroup.JoinGroupResp{}, nil
 }
 
-func (g *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq) (*pbgroup.QuitGroupResp, error) {
+func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq) (*pbgroup.QuitGroupResp, error) {
 	if req.UserID == "" {
 		req.UserID = mcontext.GetOpUserID(ctx)
 	} else {
-		if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+		if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 			return nil, err
 		}
 	}
-	member, err := g.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
+	member, err := s.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
 	if err != nil {
 		return nil, err
 	}
 	if member.RoleLevel == constant.GroupOwner {
 		return nil, errs.ErrNoPermission.WrapMsg("group owner can't quit")
 	}
-	if err := g.PopulateGroupMember(ctx, member); err != nil {
+	if err := s.PopulateGroupMember(ctx, member); err != nil {
 		return nil, err
 	}
-	err = g.db.DeleteGroupMember(ctx, req.GroupID, []string{req.UserID})
+	err = s.db.DeleteGroupMember(ctx, req.GroupID, []string{req.UserID})
 	if err != nil {
 		return nil, err
 	}
-	g.notification.MemberQuitNotification(ctx, g.groupMemberDB2PB(member, 0))
-	if err := g.deleteMemberAndSetConversationSeq(ctx, req.GroupID, []string{req.UserID}); err != nil {
+	s.notification.MemberQuitNotification(ctx, s.groupMemberDB2PB(member, 0))
+	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, []string{req.UserID}); err != nil {
 		return nil, err
 	}
-	g.webhookAfterQuitGroup(ctx, &g.config.WebhooksConfig.AfterQuitGroup, req)
+	s.webhookAfterQuitGroup(ctx, &s.config.WebhooksConfig.AfterQuitGroup, req)
 
 	return &pbgroup.QuitGroupResp{}, nil
 }
 
-func (g *groupServer) deleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
+func (s *groupServer) deleteMemberAndSetConversationSeq(ctx context.Context, groupID string, userIDs []string) error {
 	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-	maxSeq, err := g.msgClient.GetConversationMaxSeq(ctx, conversationID)
+	maxSeq, err := s.msgClient.GetConversationMaxSeq(ctx, conversationID)
 	if err != nil {
 		return err
 	}
-	return g.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, maxSeq)
+	return s.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, maxSeq)
 }
 
-func (g *groupServer) setMemberJoinSeq(ctx context.Context, groupID string, userIDs []string) error {
+func (s *groupServer) setMemberJoinSeq(ctx context.Context, groupID string, userIDs []string) error {
 	conversationID := msgprocessor.GetConversationIDBySessionType(constant.ReadGroupChatType, groupID)
-	return g.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, math.MaxInt64)
+	return s.conversationClient.SetConversationMaxSeq(ctx, conversationID, userIDs, math.MaxInt64)
 }
 
-func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInfoReq) (*pbgroup.SetGroupInfoResp, error) {
+func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInfoReq) (*pbgroup.SetGroupInfoResp, error) {
 	var opMember *model.GroupMember
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		var err error
-		opMember, err = g.db.TakeGroupMember(ctx, req.GroupInfoForSet.GroupID, mcontext.GetOpUserID(ctx))
+		opMember, err = s.db.TakeGroupMember(ctx, req.GroupInfoForSet.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
 		if !(opMember.RoleLevel == constant.GroupOwner || opMember.RoleLevel == constant.GroupAdmin) {
 			return nil, errs.ErrNoPermission.WrapMsg("no group owner or admin")
 		}
-		if err := g.PopulateGroupMember(ctx, opMember); err != nil {
+		if err := s.PopulateGroupMember(ctx, opMember); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := g.webhookBeforeSetGroupInfo(ctx, &g.config.WebhooksConfig.BeforeSetGroupInfo, req); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeSetGroupInfo(ctx, &s.config.WebhooksConfig.BeforeSetGroupInfo, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
-	group, err := g.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -1056,35 +1056,35 @@ func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 		return nil, servererrs.ErrDismissedAlready.Wrap()
 	}
 
-	count, err := g.db.FindGroupMemberNum(ctx, group.GroupID)
+	count, err := s.db.FindGroupMemberNum(ctx, group.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	owner, err := g.db.TakeGroupOwner(ctx, group.GroupID)
+	owner, err := s.db.TakeGroupOwner(ctx, group.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, owner); err != nil {
+	if err := s.PopulateGroupMember(ctx, owner); err != nil {
 		return nil, err
 	}
 	update := UpdateGroupInfoMap(ctx, req.GroupInfoForSet)
 	if len(update) == 0 {
 		return &pbgroup.SetGroupInfoResp{}, nil
 	}
-	if err := g.db.UpdateGroup(ctx, group.GroupID, update); err != nil {
+	if err := s.db.UpdateGroup(ctx, group.GroupID, update); err != nil {
 		return nil, err
 	}
-	group, err = g.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
+	group, err = s.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
 	if err != nil {
 		return nil, err
 	}
 	tips := &sdkws.GroupInfoSetTips{
-		Group:    g.groupDB2PB(group, owner.UserID, count),
+		Group:    s.groupDB2PB(group, owner.UserID, count),
 		MuteTime: 0,
 		OpUser:   &sdkws.GroupMemberFullInfo{},
 	}
 	if opMember != nil {
-		tips.OpUser = g.groupMemberDB2PB(opMember, 0)
+		tips.OpUser = s.groupMemberDB2PB(opMember, 0)
 	}
 	num := len(update)
 	if req.GroupInfoForSet.Notification != "" {
@@ -1095,39 +1095,39 @@ func (g *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 				ConversationType: constant.ReadGroupChatType,
 				GroupID:          req.GroupInfoForSet.GroupID,
 			}
-			resp, err := g.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupInfoForSet.GroupID})
+			resp, err := s.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupInfoForSet.GroupID})
 			if err != nil {
 				log.ZWarn(ctx, "GetGroupMemberIDs is failed.", err)
 				return
 			}
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
-			if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
+			if err := s.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
 				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 			}
 		}()
 		notficationFlag := true
-		g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notficationFlag)
+		s.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notficationFlag)
 	}
 	if req.GroupInfoForSet.GroupName != "" {
 		num--
-		g.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
+		s.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 	if num > 0 {
-		g.notification.GroupInfoSetNotification(ctx, tips)
+		s.notification.GroupInfoSetNotification(ctx, tips)
 	}
 
-	g.webhookAfterSetGroupInfo(ctx, &g.config.WebhooksConfig.AfterSetGroupInfo, req)
+	s.webhookAfterSetGroupInfo(ctx, &s.config.WebhooksConfig.AfterSetGroupInfo, req)
 
 	return &pbgroup.SetGroupInfoResp{}, nil
 }
 
-func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupInfoExReq) (*pbgroup.SetGroupInfoExResp, error) {
+func (s *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupInfoExReq) (*pbgroup.SetGroupInfoExResp, error) {
 	var opMember *model.GroupMember
 
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		var err error
 
-		opMember, err = g.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+		opMember, err = s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -1136,16 +1136,16 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 			return nil, errs.ErrNoPermission.WrapMsg("no group owner or admin")
 		}
 
-		if err := g.PopulateGroupMember(ctx, opMember); err != nil {
+		if err := s.PopulateGroupMember(ctx, opMember); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := g.webhookBeforeSetGroupInfoEx(ctx, &g.config.WebhooksConfig.BeforeSetGroupInfoEx, req); err != nil && err != servererrs.ErrCallbackContinue {
+	if err := s.webhookBeforeSetGroupInfoEx(ctx, &s.config.WebhooksConfig.BeforeSetGroupInfoEx, req); err != nil && err != servererrs.ErrCallbackContinue {
 		return nil, err
 	}
 
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -1153,17 +1153,17 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		return nil, servererrs.ErrDismissedAlready.Wrap()
 	}
 
-	count, err := g.db.FindGroupMemberNum(ctx, group.GroupID)
+	count, err := s.db.FindGroupMemberNum(ctx, group.GroupID)
 	if err != nil {
 		return nil, err
 	}
 
-	owner, err := g.db.TakeGroupOwner(ctx, group.GroupID)
+	owner, err := s.db.TakeGroupOwner(ctx, group.GroupID)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := g.PopulateGroupMember(ctx, owner); err != nil {
+	if err := s.PopulateGroupMember(ctx, owner); err != nil {
 		return nil, err
 	}
 
@@ -1176,23 +1176,23 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 		return nil, err
 	}
 
-	if err := g.db.UpdateGroup(ctx, group.GroupID, updatedData); err != nil {
+	if err := s.db.UpdateGroup(ctx, group.GroupID, updatedData); err != nil {
 		return nil, err
 	}
 
-	group, err = g.db.TakeGroup(ctx, req.GroupID)
+	group, err = s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
 
 	tips := &sdkws.GroupInfoSetTips{
-		Group:    g.groupDB2PB(group, owner.UserID, count),
+		Group:    s.groupDB2PB(group, owner.UserID, count),
 		MuteTime: 0,
 		OpUser:   &sdkws.GroupMemberFullInfo{},
 	}
 
 	if opMember != nil {
-		tips.OpUser = g.groupMemberDB2PB(opMember, 0)
+		tips.OpUser = s.groupMemberDB2PB(opMember, 0)
 	}
 
 	if notificationFlag {
@@ -1203,40 +1203,40 @@ func (g *groupServer) SetGroupInfoEx(ctx context.Context, req *pbgroup.SetGroupI
 				GroupID:          req.GroupID,
 			}
 
-			resp, err := g.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupID})
+			resp, err := s.GetGroupMemberUserIDs(ctx, &pbgroup.GetGroupMemberUserIDsReq{GroupID: req.GroupID})
 			if err != nil {
 				log.ZWarn(ctx, "GetGroupMemberIDs is failed.", err)
 				return nil, err
 			}
 
 			conversation.GroupAtType = &wrapperspb.Int32Value{Value: constant.GroupNotification}
-			if err := g.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
+			if err := s.conversationClient.SetConversations(ctx, resp.UserIDs, conversation); err != nil {
 				log.ZWarn(ctx, "SetConversations", err, "UserIDs", resp.UserIDs, "conversation", conversation)
 			}
 
-			g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
+			s.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
 		} else {
 			notificationFlag = false
-			g.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
+			s.notification.GroupInfoSetAnnouncementNotification(ctx, &sdkws.GroupInfoSetAnnouncementTips{Group: tips.Group, OpUser: tips.OpUser}, &notificationFlag)
 		}
 	}
 
 	if groupNameFlag {
-		g.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
+		s.notification.GroupInfoSetNameNotification(ctx, &sdkws.GroupInfoSetNameTips{Group: tips.Group, OpUser: tips.OpUser})
 	}
 
 	// if updatedData > 0, send the normal notification
 	if normalFlag {
-		g.notification.GroupInfoSetNotification(ctx, tips)
+		s.notification.GroupInfoSetNotification(ctx, tips)
 	}
 
-	g.webhookAfterSetGroupInfoEx(ctx, &g.config.WebhooksConfig.AfterSetGroupInfoEx, req)
+	s.webhookAfterSetGroupInfoEx(ctx, &s.config.WebhooksConfig.AfterSetGroupInfoEx, req)
 
 	return &pbgroup.SetGroupInfoExResp{}, nil
 }
 
-func (g *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.TransferGroupOwnerReq) (*pbgroup.TransferGroupOwnerResp, error) {
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.TransferGroupOwnerReq) (*pbgroup.TransferGroupOwnerResp, error) {
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -1249,12 +1249,12 @@ func (g *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
 		return nil, errs.ErrArgs.WrapMsg("OldOwnerUserID == NewOwnerUserID")
 	}
 
-	members, err := g.db.FindGroupMembers(ctx, req.GroupID, []string{req.OldOwnerUserID, req.NewOwnerUserID})
+	members, err := s.db.FindGroupMembers(ctx, req.GroupID, []string{req.OldOwnerUserID, req.NewOwnerUserID})
 	if err != nil {
 		return nil, err
 	}
 
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 
@@ -1273,43 +1273,43 @@ func (g *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
 		return nil, errs.ErrArgs.WrapMsg("NewOwnerUser not in group " + req.NewOwnerUserID)
 	}
 
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		if !(mcontext.GetOpUserID(ctx) == oldOwner.UserID && oldOwner.RoleLevel == constant.GroupOwner) {
 			return nil, errs.ErrNoPermission.WrapMsg("no permission transfer group owner")
 		}
 	}
 
 	if newOwner.MuteEndTime.After(time.Now()) {
-		if _, err := g.CancelMuteGroupMember(ctx, &pbgroup.CancelMuteGroupMemberReq{
+		if _, err := s.CancelMuteGroupMember(ctx, &pbgroup.CancelMuteGroupMemberReq{
 			GroupID: group.GroupID,
 			UserID:  req.NewOwnerUserID}); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := g.db.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
+	if err := s.db.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
 		return nil, err
 	}
 
-	g.webhookAfterTransferGroupOwner(ctx, &g.config.WebhooksConfig.AfterTransferGroupOwner, req)
+	s.webhookAfterTransferGroupOwner(ctx, &s.config.WebhooksConfig.AfterTransferGroupOwner, req)
 
-	g.notification.GroupOwnerTransferredNotification(ctx, req)
+	s.notification.GroupOwnerTransferredNotification(ctx, req)
 
 	return &pbgroup.TransferGroupOwnerResp{}, nil
 }
 
-func (g *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq) (*pbgroup.GetGroupsResp, error) {
+func (s *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq) (*pbgroup.GetGroupsResp, error) {
 	var (
 		group []*model.Group
 		err   error
 	)
 	var resp pbgroup.GetGroupsResp
 	if req.GroupID != "" {
-		group, err = g.db.FindGroup(ctx, []string{req.GroupID})
+		group, err = s.db.FindGroup(ctx, []string{req.GroupID})
 		resp.Total = uint32(len(group))
 	} else {
 		var total int64
-		total, group, err = g.db.SearchGroup(ctx, req.GroupName, req.Pagination)
+		total, group, err = s.db.SearchGroup(ctx, req.GroupName, req.Pagination)
 		resp.Total = uint32(total)
 	}
 
@@ -1321,7 +1321,7 @@ func (g *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq)
 		return e.GroupID
 	})
 
-	ownerMembers, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	ownerMembers, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1329,7 +1329,7 @@ func (g *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq)
 	ownerMemberMap := datautil.SliceToMap(ownerMembers, func(e *model.GroupMember) string {
 		return e.GroupID
 	})
-	groupMemberNumMap, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNumMap, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1347,17 +1347,17 @@ func (g *groupServer) GetGroups(ctx context.Context, req *pbgroup.GetGroupsReq)
 	return &resp, nil
 }
 
-func (g *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGroupMembersCMSReq) (*pbgroup.GetGroupMembersCMSResp, error) {
-	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGroupMembersCMSReq) (*pbgroup.GetGroupMembersCMSResp, error) {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
-	total, members, err := g.db.SearchGroupMember(ctx, req.UserName, req.GroupID, req.Pagination)
+	total, members, err := s.db.SearchGroupMember(ctx, req.UserName, req.GroupID, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
 	var resp pbgroup.GetGroupMembersCMSResp
 	resp.Total = uint32(total)
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp.Members = datautil.Slice(members, func(e *model.GroupMember) *sdkws.GroupMemberFullInfo {
@@ -1366,15 +1366,15 @@ func (g *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGr
 	return &resp, nil
 }
 
-func (g *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgroup.GetUserReqApplicationListReq) (*pbgroup.GetUserReqApplicationListResp, error) {
-	user, err := g.userClient.GetUserInfo(ctx, req.UserID)
+func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgroup.GetUserReqApplicationListReq) (*pbgroup.GetUserReqApplicationListResp, error) {
+	user, err := s.userClient.GetUserInfo(ctx, req.UserID)
 	if err != nil {
 		return nil, err
 	}
 	handleResults := datautil.Slice(req.HandleResults, func(e int32) int {
 		return int(e)
 	})
-	total, requests, err := g.db.PageGroupRequestUser(ctx, req.UserID, req.GroupIDs, handleResults, req.Pagination)
+	total, requests, err := s.db.PageGroupRequestUser(ctx, req.UserID, req.GroupIDs, handleResults, req.Pagination)
 	if err != nil {
 		return nil, err
 	}
@@ -1384,24 +1384,24 @@ func (g *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgrou
 	groupIDs := datautil.Distinct(datautil.Slice(requests, func(e *model.GroupRequest) string {
 		return e.GroupID
 	}))
-	groups, err := g.db.FindGroup(ctx, groupIDs)
+	groups, err := s.db.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
 	groupMap := datautil.SliceToMap(groups, func(e *model.Group) string {
 		return e.GroupID
 	})
-	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	owners, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, owners...); err != nil {
+	if err := s.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
 	ownerMap := datautil.SliceToMap(owners, func(e *model.GroupMember) string {
 		return e.GroupID
 	})
-	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNum, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1417,44 +1417,44 @@ func (g *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgrou
 	}, nil
 }
 
-func (g *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGroupReq) (*pbgroup.DismissGroupResp, error) {
-	owner, err := g.db.TakeGroupOwner(ctx, req.GroupID)
+func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGroupReq) (*pbgroup.DismissGroupResp, error) {
+	owner, err := s.db.TakeGroupOwner(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		if owner.UserID != mcontext.GetOpUserID(ctx) {
 			return nil, errs.ErrNoPermission.WrapMsg("not group owner")
 		}
 	}
-	if err := g.PopulateGroupMember(ctx, owner); err != nil {
+	if err := s.PopulateGroupMember(ctx, owner); err != nil {
 		return nil, err
 	}
-	group, err := g.db.TakeGroup(ctx, req.GroupID)
+	group, err := s.db.TakeGroup(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
 	if !req.DeleteMember && group.Status == constant.GroupStatusDismissed {
 		return nil, servererrs.ErrDismissedAlready.WrapMsg("group status is dismissed")
 	}
-	if err := g.db.DismissGroup(ctx, req.GroupID, req.DeleteMember); err != nil {
+	if err := s.db.DismissGroup(ctx, req.GroupID, req.DeleteMember); err != nil {
 		return nil, err
 	}
 	if !req.DeleteMember {
-		num, err := g.db.FindGroupMemberNum(ctx, req.GroupID)
+		num, err := s.db.FindGroupMemberNum(ctx, req.GroupID)
 		if err != nil {
 			return nil, err
 		}
 		tips := &sdkws.GroupDismissedTips{
-			Group:  g.groupDB2PB(group, owner.UserID, num),
+			Group:  s.groupDB2PB(group, owner.UserID, num),
 			OpUser: &sdkws.GroupMemberFullInfo{},
 		}
 		if mcontext.GetOpUserID(ctx) == owner.UserID {
-			tips.OpUser = g.groupMemberDB2PB(owner, 0)
+			tips.OpUser = s.groupMemberDB2PB(owner, 0)
 		}
-		g.notification.GroupDismissedNotification(ctx, tips, req.SendMessage)
+		s.notification.GroupDismissedNotification(ctx, tips, req.SendMessage)
 	}
-	membersID, err := g.db.FindGroupMemberUserID(ctx, group.GroupID)
+	membersID, err := s.db.FindGroupMemberUserID(ctx, group.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -1465,21 +1465,21 @@ func (g *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
 		GroupType: string(group.GroupType),
 	}
 
-	g.webhookAfterDismissGroup(ctx, &g.config.WebhooksConfig.AfterDismissGroup, cbReq)
+	s.webhookAfterDismissGroup(ctx, &s.config.WebhooksConfig.AfterDismissGroup, cbReq)
 
 	return &pbgroup.DismissGroupResp{}, nil
 }
 
-func (g *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGroupMemberReq) (*pbgroup.MuteGroupMemberResp, error) {
-	member, err := g.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
+func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGroupMemberReq) (*pbgroup.MuteGroupMemberResp, error) {
+	member, err := s.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, member); err != nil {
+	if err := s.PopulateGroupMember(ctx, member); err != nil {
 		return nil, err
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
-		opMember, err := g.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
+		opMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -1497,25 +1497,25 @@ func (g *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGrou
 		}
 	}
 	data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds)))
-	if err := g.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
+	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
-	g.notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
+	s.notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
 	return &pbgroup.MuteGroupMemberResp{}, nil
 }
 
-func (g *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.CancelMuteGroupMemberReq) (*pbgroup.CancelMuteGroupMemberResp, error) {
-	member, err := g.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
+func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.CancelMuteGroupMemberReq) (*pbgroup.CancelMuteGroupMemberResp, error) {
+	member, err := s.db.TakeGroupMember(ctx, req.GroupID, req.UserID)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := g.PopulateGroupMember(ctx, member); err != nil {
+	if err := s.PopulateGroupMember(ctx, member); err != nil {
 		return nil, err
 	}
 
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
-		opMember, err := g.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
+		opMember, err := s.db.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -1535,38 +1535,38 @@ func (g *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.Ca
 	}
 
 	data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0))
-	if err := g.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
+	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
 
-	g.notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
+	s.notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
 
 	return &pbgroup.CancelMuteGroupMemberResp{}, nil
 }
 
-func (g *groupServer) MuteGroup(ctx context.Context, req *pbgroup.MuteGroupReq) (*pbgroup.MuteGroupResp, error) {
-	if err := g.CheckGroupAdmin(ctx, req.GroupID); err != nil {
+func (s *groupServer) MuteGroup(ctx context.Context, req *pbgroup.MuteGroupReq) (*pbgroup.MuteGroupResp, error) {
+	if err := s.CheckGroupAdmin(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
-	if err := g.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupStatusMuted)); err != nil {
+	if err := s.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupStatusMuted)); err != nil {
 		return nil, err
 	}
-	g.notification.GroupMutedNotification(ctx, req.GroupID)
+	s.notification.GroupMutedNotification(ctx, req.GroupID)
 	return &pbgroup.MuteGroupResp{}, nil
 }
 
-func (g *groupServer) CancelMuteGroup(ctx context.Context, req *pbgroup.CancelMuteGroupReq) (*pbgroup.CancelMuteGroupResp, error) {
-	if err := g.CheckGroupAdmin(ctx, req.GroupID); err != nil {
+func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbgroup.CancelMuteGroupReq) (*pbgroup.CancelMuteGroupResp, error) {
+	if err := s.CheckGroupAdmin(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
-	if err := g.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupOk)); err != nil {
+	if err := s.db.UpdateGroup(ctx, req.GroupID, UpdateGroupStatusMap(constant.GroupOk)); err != nil {
 		return nil, err
 	}
-	g.notification.GroupCancelMutedNotification(ctx, req.GroupID)
+	s.notification.GroupCancelMutedNotification(ctx, req.GroupID)
 	return &pbgroup.CancelMuteGroupResp{}, nil
 }
 
-func (g *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGroupMemberInfoReq) (*pbgroup.SetGroupMemberInfoResp, error) {
+func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGroupMemberInfoReq) (*pbgroup.SetGroupMemberInfoResp, error) {
 	if len(req.Members) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("members empty")
 	}
@@ -1574,7 +1574,7 @@ func (g *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
 	if opUserID == "" {
 		return nil, errs.ErrNoPermission.WrapMsg("no op user id")
 	}
-	isAppManagerUid := authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID)
+	isAppManagerUid := authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID)
 	groupMembers := make(map[string][]*pbgroup.SetGroupMemberInfo)
 	for i, member := range req.Members {
 		if member.RoleLevel != nil {
@@ -1601,7 +1601,7 @@ func (g *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
 		if _, ok := temp[opUserID]; !ok {
 			userIDs = append(userIDs, opUserID)
 		}
-		dbMembers, err := g.db.FindGroupMembers(ctx, groupID, userIDs)
+		dbMembers, err := s.db.FindGroupMembers(ctx, groupID, userIDs)
 		if err != nil {
 			return nil, err
 		}
@@ -1688,12 +1688,12 @@ func (g *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
 
 	for i := 0; i < len(req.Members); i++ {
 
-		if err := g.webhookBeforeSetGroupMemberInfo(ctx, &g.config.WebhooksConfig.BeforeSetGroupMemberInfo, req.Members[i]); err != nil && err != servererrs.ErrCallbackContinue {
+		if err := s.webhookBeforeSetGroupMemberInfo(ctx, &s.config.WebhooksConfig.BeforeSetGroupMemberInfo, req.Members[i]); err != nil && err != servererrs.ErrCallbackContinue {
 			return nil, err
 		}
 
 	}
-	if err := g.db.UpdateGroupMembers(ctx, datautil.Slice(req.Members, func(e *pbgroup.SetGroupMemberInfo) *common.BatchUpdateGroupMember {
+	if err := s.db.UpdateGroupMembers(ctx, datautil.Slice(req.Members, func(e *pbgroup.SetGroupMemberInfo) *common.BatchUpdateGroupMember {
 		return &common.BatchUpdateGroupMember{
 			GroupID: e.GroupID,
 			UserID:  e.UserID,
@@ -1706,23 +1706,23 @@ func (g *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
 		if member.RoleLevel != nil {
 			switch member.RoleLevel.Value {
 			case constant.GroupAdmin:
-				g.notification.GroupMemberSetToAdminNotification(ctx, member.GroupID, member.UserID)
+				s.notification.GroupMemberSetToAdminNotification(ctx, member.GroupID, member.UserID)
 			case constant.GroupOrdinaryUsers:
-				g.notification.GroupMemberSetToOrdinaryUserNotification(ctx, member.GroupID, member.UserID)
+				s.notification.GroupMemberSetToOrdinaryUserNotification(ctx, member.GroupID, member.UserID)
 			}
 		}
 		if member.Nickname != nil || member.FaceURL != nil || member.Ex != nil {
-			g.notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
+			s.notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
 		}
 	}
 	for i := 0; i < len(req.Members); i++ {
-		g.webhookAfterSetGroupMemberInfo(ctx, &g.config.WebhooksConfig.AfterSetGroupMemberInfo, req.Members[i])
+		s.webhookAfterSetGroupMemberInfo(ctx, &s.config.WebhooksConfig.AfterSetGroupMemberInfo, req.Members[i])
 	}
 
 	return &pbgroup.SetGroupMemberInfoResp{}, nil
 }
 
-func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.GetGroupAbstractInfoReq) (*pbgroup.GetGroupAbstractInfoResp, error) {
+func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.GetGroupAbstractInfoReq) (*pbgroup.GetGroupAbstractInfoResp, error) {
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("groupIDs empty")
 	}
@@ -1730,11 +1730,11 @@ func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.Get
 		return nil, errs.ErrArgs.WrapMsg("groupIDs duplicate")
 	}
 	for _, groupID := range req.GroupIDs {
-		if err := g.checkAdminOrInGroup(ctx, groupID); err != nil {
+		if err := s.checkAdminOrInGroup(ctx, groupID); err != nil {
 			return nil, err
 		}
 	}
-	groups, err := g.db.FindGroup(ctx, req.GroupIDs)
+	groups, err := s.db.FindGroup(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1743,7 +1743,7 @@ func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.Get
 	})); len(ids) > 0 {
 		return nil, servererrs.ErrGroupIDNotFound.WrapMsg("not found group " + strings.Join(ids, ","))
 	}
-	groupUserMap, err := g.db.MapGroupMemberUserID(ctx, req.GroupIDs)
+	groupUserMap, err := s.db.MapGroupMemberUserID(ctx, req.GroupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1758,18 +1758,18 @@ func (g *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbgroup.Get
 	}, nil
 }
 
-func (g *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.GetUserInGroupMembersReq) (*pbgroup.GetUserInGroupMembersResp, error) {
+func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.GetUserInGroupMembersReq) (*pbgroup.GetUserInGroupMembersResp, error) {
 	if len(req.GroupIDs) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("groupIDs empty")
 	}
-	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
-	members, err := g.db.FindGroupMemberUser(ctx, req.GroupIDs, req.UserID)
+	members, err := s.db.FindGroupMemberUser(ctx, req.GroupIDs, req.UserID)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	return &pbgroup.GetUserInGroupMembersResp{
@@ -1779,12 +1779,12 @@ func (g *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.Ge
 	}, nil
 }
 
-func (g *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetGroupMemberUserIDsReq) (*pbgroup.GetGroupMemberUserIDsResp, error) {
-	userIDs, err := g.db.FindGroupMemberUserID(ctx, req.GroupID)
+func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetGroupMemberUserIDsReq) (*pbgroup.GetGroupMemberUserIDsResp, error) {
+	userIDs, err := s.db.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		if !datautil.Contain(mcontext.GetOpUserID(ctx), userIDs...) {
 			return nil, errs.ErrNoPermission.WrapMsg("opUser no permission")
 		}
@@ -1794,18 +1794,18 @@ func (g *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbgroup.Ge
 	}, nil
 }
 
-func (g *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbgroup.GetGroupMemberRoleLevelReq) (*pbgroup.GetGroupMemberRoleLevelResp, error) {
+func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbgroup.GetGroupMemberRoleLevelReq) (*pbgroup.GetGroupMemberRoleLevelResp, error) {
 	if len(req.RoleLevels) == 0 {
 		return nil, errs.ErrArgs.WrapMsg("RoleLevels empty")
 	}
-	if err := g.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
+	if err := s.checkAdminOrInGroup(ctx, req.GroupID); err != nil {
 		return nil, err
 	}
-	members, err := g.db.FindGroupMemberRoleLevels(ctx, req.GroupID, req.RoleLevels)
+	members, err := s.db.FindGroupMemberRoleLevels(ctx, req.GroupID, req.RoleLevels)
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err := s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	return &pbgroup.GetGroupMemberRoleLevelResp{
@@ -1815,8 +1815,8 @@ func (g *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbgroup.
 	}, nil
 }
 
-func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *pbgroup.GetGroupUsersReqApplicationListReq) (*pbgroup.GetGroupUsersReqApplicationListResp, error) {
-	requests, err := g.db.FindGroupRequests(ctx, req.GroupID, req.UserIDs)
+func (s *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *pbgroup.GetGroupUsersReqApplicationListReq) (*pbgroup.GetGroupUsersReqApplicationListResp, error) {
+	requests, err := s.db.FindGroupRequests(ctx, req.GroupID, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1829,7 +1829,7 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 		return e.GroupID
 	}))
 
-	groups, err := g.db.FindGroup(ctx, groupIDs)
+	groups, err := s.db.FindGroup(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1842,17 +1842,17 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 		return nil, servererrs.ErrGroupIDNotFound.WrapMsg(strings.Join(ids, ","))
 	}
 
-	userMap, err := g.userClient.GetUsersInfoMap(ctx, req.UserIDs)
+	userMap, err := s.userClient.GetUsersInfoMap(ctx, req.UserIDs)
 	if err != nil {
 		return nil, err
 	}
 
-	owners, err := g.db.FindGroupsOwner(ctx, groupIDs)
+	owners, err := s.db.FindGroupsOwner(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := g.PopulateGroupMember(ctx, owners...); err != nil {
+	if err := s.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
 
@@ -1860,7 +1860,7 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 		return e.GroupID
 	})
 
-	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, groupIDs)
+	groupMemberNum, err := s.db.MapGroupMemberNum(ctx, groupIDs)
 	if err != nil {
 		return nil, err
 	}
@@ -1883,29 +1883,29 @@ func (g *groupServer) GetGroupUsersReqApplicationList(ctx context.Context, req *
 	}, nil
 }
 
-func (g *groupServer) GetSpecifiedUserGroupRequestInfo(ctx context.Context, req *pbgroup.GetSpecifiedUserGroupRequestInfoReq) (*pbgroup.GetSpecifiedUserGroupRequestInfoResp, error) {
+func (s *groupServer) GetSpecifiedUserGroupRequestInfo(ctx context.Context, req *pbgroup.GetSpecifiedUserGroupRequestInfoReq) (*pbgroup.GetSpecifiedUserGroupRequestInfoResp, error) {
 	opUserID := mcontext.GetOpUserID(ctx)
 
-	owners, err := g.db.FindGroupsOwner(ctx, []string{req.GroupID})
+	owners, err := s.db.FindGroupsOwner(ctx, []string{req.GroupID})
 	if err != nil {
 		return nil, err
 	}
 
 	if req.UserID != opUserID {
-		adminIDs, err := g.db.GetGroupRoleLevelMemberIDs(ctx, req.GroupID, constant.GroupAdmin)
+		adminIDs, err := s.db.GetGroupRoleLevelMemberIDs(ctx, req.GroupID, constant.GroupAdmin)
 		if err != nil {
 			return nil, err
 		}
 
 		adminIDs = append(adminIDs, owners[0].UserID)
-		adminIDs = append(adminIDs, g.config.Share.IMAdminUserID...)
+		adminIDs = append(adminIDs, s.config.Share.IMAdminUserID...)
 
 		if !datautil.Contain(opUserID, adminIDs...) {
 			return nil, errs.ErrNoPermission.WrapMsg("opUser no permission")
 		}
 	}
 
-	requests, err := g.db.FindGroupRequests(ctx, req.GroupID, []string{req.UserID})
+	requests, err := s.db.FindGroupRequests(ctx, req.GroupID, []string{req.UserID})
 	if err != nil {
 		return nil, err
 	}
@@ -1914,17 +1914,17 @@ func (g *groupServer) GetSpecifiedUserGroupRequestInfo(ctx context.Context, req
 		return &pbgroup.GetSpecifiedUserGroupRequestInfoResp{}, nil
 	}
 
-	groups, err := g.db.FindGroup(ctx, []string{req.GroupID})
+	groups, err := s.db.FindGroup(ctx, []string{req.GroupID})
 	if err != nil {
 		return nil, err
 	}
 
-	userInfos, err := g.userClient.GetUsersInfo(ctx, []string{req.UserID})
+	userInfos, err := s.userClient.GetUsersInfo(ctx, []string{req.UserID})
 	if err != nil {
 		return nil, err
 	}
 
-	groupMemberNum, err := g.db.MapGroupMemberNum(ctx, []string{req.GroupID})
+	groupMemberNum, err := s.db.MapGroupMemberNum(ctx, []string{req.GroupID})
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/rpc/group/sync.go b/internal/rpc/group/sync.go
index 1474c9003..46e95280c 100644
--- a/internal/rpc/group/sync.go
+++ b/internal/rpc/group/sync.go
@@ -2,6 +2,7 @@ package group
 
 import (
 	"context"
+	"errors"
 
 	"github.com/openimsdk/open-im-server/v3/internal/rpc/incrversion"
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
@@ -12,23 +13,24 @@ import (
 	pbgroup "github.com/openimsdk/protocol/group"
 	"github.com/openimsdk/protocol/sdkws"
 	"github.com/openimsdk/tools/errs"
+	"github.com/openimsdk/tools/log"
 	"github.com/openimsdk/tools/mcontext"
 	"github.com/openimsdk/tools/utils/datautil"
 )
 
 const versionSyncLimit = 500
 
-func (g *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetFullGroupMemberUserIDsReq) (*pbgroup.GetFullGroupMemberUserIDsResp, error) {
-	userIDs, err := g.db.FindGroupMemberUserID(ctx, req.GroupID)
+func (s *groupServer) GetFullGroupMemberUserIDs(ctx context.Context, req *pbgroup.GetFullGroupMemberUserIDsReq) (*pbgroup.GetFullGroupMemberUserIDsResp, error) {
+	userIDs, err := s.db.FindGroupMemberUserID(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
-	if !authverify.IsAppManagerUid(ctx, g.config.Share.IMAdminUserID) {
+	if !authverify.IsAppManagerUid(ctx, s.config.Share.IMAdminUserID) {
 		if !datautil.Contain(mcontext.GetOpUserID(ctx), userIDs...) {
 			return nil, errs.ErrNoPermission.WrapMsg("op user not in group")
 		}
 	}
-	vl, err := g.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
+	vl, err := s.db.FindMaxGroupMemberVersionCache(ctx, req.GroupID)
 	if err != nil {
 		return nil, err
 	}
@@ -146,8 +148,8 @@ func (s *groupServer) GetIncrementalGroupMember(ctx context.Context, req *pbgrou
 	return resp, nil
 }
 
-func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.GetIncrementalJoinGroupReq) (*pbgroup.GetIncrementalJoinGroupResp, error) {
-	if err := authverify.CheckAccessV3(ctx, req.UserID, g.config.Share.IMAdminUserID); err != nil {
+func (s *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.GetIncrementalJoinGroupReq) (*pbgroup.GetIncrementalJoinGroupResp, error) {
+	if err := authverify.CheckAccessV3(ctx, req.UserID, s.config.Share.IMAdminUserID); err != nil {
 		return nil, err
 	}
 	opt := incrversion.Option[*sdkws.GroupInfo, pbgroup.GetIncrementalJoinGroupResp]{
@@ -155,9 +157,9 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 		VersionKey:      req.UserID,
 		VersionID:       req.VersionID,
 		VersionNumber:   req.Version,
-		Version:         g.db.FindJoinIncrVersion,
-		CacheMaxVersion: g.db.FindMaxJoinGroupVersionCache,
-		Find:            g.getGroupsInfo,
+		Version:         s.db.FindJoinIncrVersion,
+		CacheMaxVersion: s.db.FindMaxJoinGroupVersionCache,
+		Find:            s.getGroupsInfo,
 		Resp: func(version *model.VersionLog, delIDs []string, insertList, updateList []*sdkws.GroupInfo, full bool) *pbgroup.GetIncrementalJoinGroupResp {
 			return &pbgroup.GetIncrementalJoinGroupResp{
 				VersionID: version.ID.Hex(),
@@ -172,22 +174,29 @@ func (g *groupServer) GetIncrementalJoinGroup(ctx context.Context, req *pbgroup.
 	return opt.Build()
 }
 
-func (g *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
+func (s *groupServer) BatchGetIncrementalGroupMember(ctx context.Context, req *pbgroup.BatchGetIncrementalGroupMemberReq) (*pbgroup.BatchGetIncrementalGroupMemberResp, error) {
 	var num int
 	resp := make(map[string]*pbgroup.GetIncrementalGroupMemberResp)
+
 	for _, memberReq := range req.ReqList {
 		if _, ok := resp[memberReq.GroupID]; ok {
 			continue
 		}
-		memberResp, err := g.GetIncrementalGroupMember(ctx, memberReq)
+		memberResp, err := s.GetIncrementalGroupMember(ctx, memberReq)
 		if err != nil {
+			if errors.Is(err, servererrs.ErrDismissedAlready) {
+				log.ZWarn(ctx, "Failed to get incremental group member", err, "groupID", memberReq.GroupID, "request", memberReq)
+				continue
+			}
 			return nil, err
 		}
+
 		resp[memberReq.GroupID] = memberResp
 		num += len(memberResp.Insert) + len(memberResp.Update) + len(memberResp.Delete)
 		if num >= versionSyncLimit {
 			break
 		}
 	}
+
 	return &pbgroup.BatchGetIncrementalGroupMemberResp{RespList: resp}, nil
 }