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

 Conflicts:

	pkg/common/db/relation/black.go

internal/common/convert/convert.go

@@ -1,7 +1,6 @@
 package convert
 
 import (
-	"Open_IM/pkg/common/db/relation"
 	"Open_IM/pkg/common/db/table"
 	sdk "Open_IM/pkg/proto/sdk_ws"
 	utils "github.com/OpenIMSDK/open_utils"
@@ -23,8 +22,8 @@ type DBFriend struct {
 	*table.FriendModel
 }
 
-func NewDBFriend(friend *controller.Friend) *DBFriend {
-	return &DBFriend{Friend: friend}
+func NewDBFriend(friend *table.FriendModel) *DBFriend {
+	return &DBFriend{FriendModel: friend}
 }
 
 type PBFriend struct {
@@ -35,6 +34,14 @@ func NewPBFriend(friendInfo *sdk.FriendInfo) *PBFriend {
 	return &PBFriend{FriendInfo: friendInfo}
 }
 
+func (*PBFriend) PB2DB(friends []*sdk.FriendInfo) (DBFriends []*table.FriendModel, err error) {
+
+}
+
+func (*DBFriend) DB2PB(friends []*table.FriendModel) (PBFriends []*sdk.FriendInfo, err error) {
+
+}
+
 func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
 	pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
 	utils.CopyStructFields(pbFriend, db)
@@ -49,8 +56,8 @@ func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
 	return pbFriend, nil
 }
 
-func (pb *PBFriend) Convert() (*relation.Friend, error) {
-	dbFriend := &relation.Friend{}
+func (pb *PBFriend) Convert() (*table.FriendModel, error) {
+	dbFriend := &table.FriendModel{}
 	utils.CopyStructFields(dbFriend, pb)
 	dbFriend.FriendUserID = pb.FriendUser.UserID
 	dbFriend.CreateTime = utils.UnixSecondToTime(pb.CreateTime)
@@ -58,11 +65,11 @@ func (pb *PBFriend) Convert() (*relation.Friend, error) {
 }
 
 type DBFriendRequest struct {
-	*relation.FriendRequest
+	*table.FriendRequestModel
 }
 
-func NewDBFriendRequest(friendRequest *relation.FriendRequest) *DBFriendRequest {
-	return &DBFriendRequest{FriendRequest: friendRequest}
+func NewDBFriendRequest(friendRequest *table.FriendRequestModel) *DBFriendRequest {
+	return &DBFriendRequest{FriendRequestModel: friendRequest}
 }
 
 type PBFriendRequest struct {
@@ -73,8 +80,16 @@ func NewPBFriendRequest(friendRequest *sdk.FriendRequest) *PBFriendRequest {
 	return &PBFriendRequest{FriendRequest: friendRequest}
 }
 
-func (pb *PBFriendRequest) Convert() (*relation.FriendRequest, error) {
-	dbFriendRequest := &relation.FriendRequest{}
+func (*PBFriendRequest) PB2DB(friendRequests []*sdk.FriendRequest) (DBFriendRequests []*table.FriendRequestModel, err error) {
+
+}
+
+func (*DBFriendRequest) DB2PB(friendRequests []*table.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) {
+
+}
+
+func (pb *PBFriendRequest) Convert() (*table.FriendRequestModel, error) {
+	dbFriendRequest := &table.FriendRequestModel{}
 	utils.CopyStructFields(dbFriendRequest, pb)
 	dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
 	dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@@ -103,11 +118,19 @@ func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) {
 }
 
 type DBBlack struct {
-	*relation.Black
+	*table.BlackModel
 }
 
-func NewDBBlack(black *relation.Black) *DBBlack {
-	return &DBBlack{Black: black}
+func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*table.BlackModel, err error) {
+
+}
+
+func (*DBBlack) DB2PB(blacks []*table.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) {
+
+}
+
+func NewDBBlack(black *table.BlackModel) *DBBlack {
+	return &DBBlack{BlackModel: black}
 }
 
 type PBBlack struct {
@@ -118,8 +141,8 @@ func NewPBBlack(blackInfo *sdk.BlackInfo) *PBBlack {
 	return &PBBlack{BlackInfo: blackInfo}
 }
 
-func (pb *PBBlack) Convert() (*relation.Black, error) {
-	dbBlack := &relation.Black{}
+func (pb *PBBlack) Convert() (*table.BlackModel, error) {
+	dbBlack := &table.BlackModel{}
 	dbBlack.BlockUserID = pb.BlackUserInfo.UserID
 	dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
 	return dbBlack, nil
@@ -137,11 +160,19 @@ func (db *DBBlack) Convert() (*sdk.BlackInfo, error) {
 }
 
 type DBGroup struct {
-	*relation.Group
+	*table.GroupModel
 }
 
-func NewDBGroup(group *relation.Group) *DBGroup {
-	return &DBGroup{Group: group}
+func (*PBGroup) PB2DB(groups []*sdk.GroupInfo) (DBGroups []*table.GroupModel, err error) {
+
+}
+
+func (*DBGroup) DB2PB(groups []*table.GroupModel) (PBGroups []*sdk.GroupInfo, err error) {
+
+}
+
+func NewDBGroup(group *table.GroupModel) *DBGroup {
+	return &DBGroup{GroupModel: group}
 }
 
 type PBGroup struct {
@@ -152,8 +183,8 @@ func NewPBGroup(groupInfo *sdk.GroupInfo) *PBGroup {
 	return &PBGroup{GroupInfo: groupInfo}
 }
 
-func (pb *PBGroup) Convert() *relation.Group {
-	dst := &relation.Group{}
+func (pb *PBGroup) Convert() *table.GroupModel {
+	dst := &table.GroupModel{}
 	_ = utils.CopyStructFields(dst, pb)
 	return dst
 }
@@ -180,11 +211,19 @@ func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
 }
 
 type DBGroupMember struct {
-	*relation.GroupMember
+	*table.GroupMemberModel
 }
 
-func NewDBGroupMember(groupMember *relation.GroupMember) *DBGroupMember {
-	return &DBGroupMember{GroupMember: groupMember}
+func (*PBGroupMember) PB2DB(groupMembers []*sdk.GroupMemberFullInfo) (DBGroupMembers []*table.GroupMemberModel, err error) {
+
+}
+
+func (*DBGroupMember) DB2PB(groupMembers []*table.GroupMemberModel) (PBGroupMembers []*sdk.GroupMemberFullInfo, err error) {
+
+}
+
+func NewDBGroupMember(groupMember *table.GroupMemberModel) *DBGroupMember {
+	return &DBGroupMember{GroupMemberModel: groupMember}
 }
 
 type PBGroupMember struct {
@@ -195,8 +234,8 @@ func NewPBGroupMember(groupMemberFullInfo *sdk.GroupMemberFullInfo) *PBGroupMemb
 	return &PBGroupMember{GroupMemberFullInfo: groupMemberFullInfo}
 }
 
-func (pb *PBGroupMember) Convert() (*relation.GroupMember, error) {
-	dst := &relation.GroupMember{}
+func (pb *PBGroupMember) Convert() (*table.GroupMemberModel, error) {
+	dst := &table.GroupMemberModel{}
 	utils.CopyStructFields(dst, pb)
 	dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
 	dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
@@ -224,11 +263,19 @@ func (db *DBGroupMember) Convert() (*sdk.GroupMemberFullInfo, error) {
 }
 
 type DBGroupRequest struct {
-	*relation.GroupRequest
+	*table.GroupRequestModel
 }
 
-func NewDBGroupRequest(groupRequest *relation.GroupRequest) *DBGroupRequest {
-	return &DBGroupRequest{GroupRequest: groupRequest}
+func (*PBGroupRequest) PB2DB(groupRequests []*sdk.GroupRequest) (DBGroupRequests []*table.GroupRequestModel, err error) {
+
+}
+
+func (*DBGroupRequest) DB2PB(groupRequests []*table.GroupRequestModel) (PBGroupRequests []*sdk.GroupRequest, err error) {
+
+}
+
+func NewDBGroupRequest(groupRequest *table.GroupRequestModel) *DBGroupRequest {
+	return &DBGroupRequest{GroupRequestModel: groupRequest}
 }
 
 type PBGroupRequest struct {
@@ -239,8 +286,8 @@ func NewPBGroupRequest(groupRequest *sdk.GroupRequest) *PBGroupRequest {
 	return &PBGroupRequest{GroupRequest: groupRequest}
 }
 
-func (pb *PBGroupRequest) Convert() (*relation.GroupRequest, error) {
-	dst := &relation.GroupRequest{}
+func (pb *PBGroupRequest) Convert() (*table.GroupRequestModel, error) {
+	dst := &table.GroupRequestModel{}
 	utils.CopyStructFields(dst, pb)
 	dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
 	dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@@ -255,11 +302,11 @@ func (db *DBGroupRequest) Convert() (*sdk.GroupRequest, error) {
 }
 
 type DBUser struct {
-	*relation.User
+	*table.UserModel
 }
 
-func NewDBUser(user *relation.User) *DBUser {
-	return &DBUser{User: user}
+func NewDBUser(user *table.UserModel) *DBUser {
+	return &DBUser{UserModel: user}
 }
 
 type PBUser struct {
@@ -270,7 +317,7 @@ func NewPBUser(userInfo *sdk.UserInfo) *PBUser {
 	return &PBUser{UserInfo: userInfo}
 }
 
-func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*relation.User, err error) {
+func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*table.UserModel, err error) {
 	for _, v := range users {
 		u, err := NewPBUser(v).Convert()
 		if err != nil {
@@ -281,7 +328,7 @@ func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*relation.User, err error
 	return
 }
 
-func (*DBUser) DB2PB(users []*relation.User) (PBUsers []*sdk.UserInfo, err error) {
+func (*DBUser) DB2PB(users []*table.UserModel) (PBUsers []*sdk.UserInfo, err error) {
 	for _, v := range users {
 		u, err := NewDBUser(v).Convert()
 		if err != nil {
@@ -292,8 +339,8 @@ func (*DBUser) DB2PB(users []*relation.User) (PBUsers []*sdk.UserInfo, err error
 	return
 }
 
-func (pb *PBUser) Convert() (*relation.User, error) {
-	dst := &relation.User{}
+func (pb *PBUser) Convert() (*table.UserModel, error) {
+	dst := &table.UserModel{}
 	utils.CopyStructFields(dst, pb)
 	dst.Birth = utils.UnixSecondToTime(pb.Birthday)
 	dst.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))

internal/rpc/friend/black.go

@@ -4,7 +4,7 @@ import (
 	"Open_IM/internal/common/check"
 	"Open_IM/internal/common/convert"
 	chat "Open_IM/internal/rpc/msg"
-	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/db/table"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tracelog"
 	pbFriend "Open_IM/pkg/proto/friend"
@@ -20,15 +20,11 @@ func (s *friendServer) GetBlacks(ctx context.Context, req *pbFriend.GetBlacksReq
 	if err != nil {
 		return nil, err
 	}
-	blackIDList := make([]string, 0, len(blacks))
-	for _, black := range blacks {
-		b, err := convert.NewDBBlack(black).Convert()
-		if err != nil {
-			return nil, err
-		}
-		resp.Blacks = append(resp.Blacks, b)
-		blackIDList = append(blackIDList, black.BlockUserID)
+	resp.Blacks, err = (*convert.DBBlack)(nil).DB2PB(blacks)
+	if err != nil {
+		return nil, err
 	}
+
 	resp.Total = int32(total)
 	return resp, nil
 }
@@ -49,10 +45,10 @@ func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlac
 	if err := check.Access(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	if err := s.BlackInterface.Delete(ctx, []*relation.Black{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
+	if err := s.BlackInterface.Delete(ctx, []*table.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
 		return nil, err
 	}
-	chat.BlackDeletedNotification(req)
+	chat.BlackDeletedNotification(ctx, req)
 	return resp, nil
 }
 
@@ -61,10 +57,10 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	black := relation.Black{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
-	if err := s.BlackInterface.Create(ctx, []*relation.Black{&black}); err != nil {
+	black := table.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
+	if err := s.BlackInterface.Create(ctx, []*table.BlackModel{&black}); err != nil {
 		return nil, err
 	}
-	chat.BlackAddedNotification(tracelog.GetOperationID(ctx), req)
+	chat.BlackAddedNotification(ctx, req)
 	return resp, nil
 }

internal/rpc/group/copy.go

@@ -0,0 +1 @@
+package group

internal/rpc/group/group.go

@@ -191,8 +191,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
-	var group relation.GroupGorm
-	var groupMembers []*relation.GroupMember
+	var group table.GroupModel
+	var groupMembers []*table.GroupMemberModel
 	utils.CopyStructFields(&group, req.GroupInfo)
 	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
 	if req.GroupInfo.GroupType == constant.SuperGroup {
@@ -202,7 +202,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	} else {
 		joinGroup := func(userID string, roleLevel int32) error {
 			user := userMap[userID]
-			groupMember := &relation.GroupMember{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
+			groupMember := &table.GroupMemberModel{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
 			utils.CopyStructFields(&groupMember, user)
 			if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
 				return err
@@ -224,7 +224,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			}
 		}
 	}
-	if err := s.GroupInterface.CreateGroup(ctx, []*relation.GroupGorm{&group}, groupMembers); err != nil {
+	if err := s.GroupInterface.CreateGroup(ctx, []*table.GroupModel{&group}, groupMembers); err != nil {
 		return nil, err
 	}
 	utils.CopyStructFields(resp.GroupInfo, group)
@@ -300,7 +300,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if err != nil {
 		return nil, err
 	}
-	memberMap := make(map[string]*relation.GroupMember)
+	memberMap := make(map[string]*table.GroupMemberModel)
 	for i, member := range members {
 		memberMap[member.GroupID] = members[i]
 	}
@@ -326,9 +326,9 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 				return nil, constant.ErrNoPermission.Wrap("not in group")
 			}
 			if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
-				var requests []*relation.GroupRequest
+				var requests []*table.GroupRequestModel
 				for _, userID := range req.InvitedUserIDs {
-					requests = append(requests, &relation.GroupRequest{
+					requests = append(requests, &table.GroupRequestModel{
 						UserID:        userID,
 						GroupID:       req.GroupID,
 						JoinSource:    constant.JoinByInvitation,
@@ -359,10 +359,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		}
 	} else {
 		opUserID := tracelog.GetOpUserID(ctx)
-		var groupMembers []*relation.GroupMember
+		var groupMembers []*table.GroupMemberModel
 		for _, userID := range req.InvitedUserIDs {
 			user := userMap[userID]
-			var member relation.GroupMember
+			var member table.GroupMemberModel
 			utils.CopyStructFields(&member, user)
 			member.GroupID = req.GroupID
 			member.RoleLevel = constant.GroupOrdinaryUsers
@@ -420,25 +420,25 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
 	return resp, nil
 }
 
-func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) {
-	opFlag := 0
-	if !token_verify.IsManagerUserID(userID) {
-		opInfo, err := relation.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
-		if err != nil {
-			return opFlag, utils.Wrap(err, "")
-		}
-		if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
-			opFlag = 0
-		} else if opInfo.RoleLevel == constant.GroupOwner {
-			opFlag = 2 // owner
-		} else {
-			opFlag = 3 // admin
-		}
-	} else {
-		opFlag = 1 // app manager
-	}
-	return opFlag, nil
-}
+//func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) {
+//	opFlag := 0
+//	if !token_verify.IsManagerUserID(userID) {
+//		opInfo, err := relation.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+//		if err != nil {
+//			return opFlag, utils.Wrap(err, "")
+//		}
+//		if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
+//			opFlag = 0
+//		} else if opInfo.RoleLevel == constant.GroupOwner {
+//			opFlag = 2 // owner
+//		} else {
+//			opFlag = 3 // admin
+//		}
+//	} else {
+//		opFlag = 1 // app manager
+//	}
+//	return opFlag, nil
+//}
 
 func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
 	resp := &pbGroup.KickGroupMemberResp{}
@@ -470,7 +470,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		if err != nil {
 			return nil, err
 		}
-		memberMap := make(map[string]*relation.GroupMember)
+		memberMap := make(map[string]*table.GroupMemberModel)
 		for i, member := range members {
 			memberMap[member.UserID] = members[i]
 		}
@@ -522,28 +522,28 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
 	return resp, nil
 }
 
-func FillGroupInfoByGroupID(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo) error {
-	group, err := relation.TakeGroupInfoByGroupID(groupID)
-	if err != nil {
-		log.Error(operationID, "TakeGroupInfoByGroupID failed ", err.Error(), groupID)
-		return utils.Wrap(err, "")
-	}
-	if group.Status == constant.GroupStatusDismissed {
-		log.Debug(operationID, " group constant.GroupStatusDismissed ", group.GroupID)
-		return utils.Wrap(constant.ErrDismissedAlready, "")
-	}
-	return utils.Wrap(cp.GroupDBCopyOpenIM(groupInfo, group), "")
-}
+//func FillGroupInfoByGroupID(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo) error {
+//	group, err := relation.TakeGroupInfoByGroupID(groupID)
+//	if err != nil {
+//		log.Error(operationID, "TakeGroupInfoByGroupID failed ", err.Error(), groupID)
+//		return utils.Wrap(err, "")
+//	}
+//	if group.Status == constant.GroupStatusDismissed {
+//		log.Debug(operationID, " group constant.GroupStatusDismissed ", group.GroupID)
+//		return utils.Wrap(constant.ErrDismissedAlready, "")
+//	}
+//	return utils.Wrap(cp.GroupDBCopyOpenIM(groupInfo, group), "")
+//}
 
-func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sdk.PublicUserInfo) error {
-	user, err := relation.TakeUserByUserID(userID)
-	if err != nil {
-		log.Error(operationID, "TakeUserByUserID failed ", err.Error(), userID)
-		return utils.Wrap(err, "")
-	}
-	cp.UserDBCopyOpenIMPublicUser(userInfo, user)
-	return nil
-}
+//func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sdk.PublicUserInfo) error {
+//	user, err := relation.TakeUserByUserID(userID)
+//	if err != nil {
+//		log.Error(operationID, "TakeUserByUserID failed ", err.Error(), userID)
+//		return utils.Wrap(err, "")
+//	}
+//	cp.UserDBCopyOpenIMPublicUser(userInfo, user)
+//	return nil
+//}
 
 func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) {
 	resp := &pbGroup.GetGroupApplicationListResp{}
@@ -575,7 +575,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if err != nil {
 		return nil, err
 	}
-	groupMap := make(map[string]*relation.GroupGorm)
+	groupMap := make(map[string]*table.GroupModel)
 	for i, group := range groups {
 		groupMap[group.GroupID] = groups[i]
 	}
@@ -648,7 +648,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		return nil, err
 	}
 	groupRequest := getDBGroupRequest(ctx, req)
-	if err := (&relation.GroupRequest{}).Update(ctx, []*relation.GroupRequest{groupRequest}); err != nil {
+	if err := (&table.GroupRequestModel{}).Update(ctx, []*table.GroupRequestModel{groupRequest}); err != nil {
 		return nil, err
 	}
 	groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
@@ -664,7 +664,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		if err != nil {
 			return nil, err
 		}
-		err = (&relation.GroupMember{}).Create(ctx, []*relation.GroupMember{member})
+		err = (&table.GroupMemberModel{}).Create(ctx, []*table.GroupMemberModel{member})
 		if err != nil {
 			return nil, err
 		}
@@ -718,7 +718,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 				return nil, err
 			}
 			//to group member
-			groupMember := relation.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
+			groupMember := table.GroupMemberModel{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
 			utils.CopyStructFields(&groupMember, us)
 			if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), &groupMember, groupInfo.Ex); err != nil {
 				return nil, err
@@ -761,7 +761,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			return resp, nil
 		}
 	}
-	var groupRequest relation.GroupRequest
+	var groupRequest table.GroupRequestModel
 	groupRequest.UserID = tracelog.GetOpUserID(ctx)
 	groupRequest.ReqMsg = req.ReqMessage
 	groupRequest.GroupID = req.GroupID
@@ -872,7 +872,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		}
 	}
 	//only administrators can set group information
-	var groupInfo relation.GroupGorm
+	var groupInfo table.GroupModel
 	utils.CopyStructFields(&groupInfo, req.GroupInfoForSet)
 	if req.GroupInfoForSet.Notification != "" {
 		groupInfo.NotificationUserID = tracelog.GetOpUserID(ctx)
@@ -932,12 +932,12 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 		return nil, err
 	}
 
-	groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
+	groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		return nil, err
 	}
-	groupMemberInfo = relation.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
+	groupMemberInfo = table.GroupMemberModel{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		return nil, err
@@ -1131,7 +1131,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 	if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
 		return nil, err
 	}
-	groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
 	groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano())
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
@@ -1166,7 +1166,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 		return nil, err
 	}
 
-	groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
 	groupMemberInfo.MuteEndTime = time.Unix(0, 0)
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
@@ -1265,7 +1265,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
 		return nil, err
 	}
 	nickName := cbReq.Nickname.Value
-	groupMemberInfo := relation.GroupMember{}
+	groupMemberInfo := table.GroupMemberModel{}
 	groupMemberInfo.UserID = req.UserID
 	groupMemberInfo.GroupID = req.GroupID
 	if nickName == "" {
@@ -1298,7 +1298,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 	if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil {
 		return nil, err
 	}
-	groupMember := relation.GroupMember{
+	groupMember := table.GroupMemberModel{
 		GroupID: req.GroupID,
 		UserID:  req.UserID,
 	}

internal/rpc/user/user.go

@@ -7,6 +7,7 @@ import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
+	"Open_IM/pkg/common/db/table"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
@@ -45,7 +46,7 @@ func NewUserServer(port int) *userServer {
 	}
 	//mysql init
 	var mysql relation.Mysql
-	var model relation.User
+	var model relation.UserGorm
 	err := mysql.InitConn().AutoMigrateModel(&model)
 	if err != nil {
 		panic("db init err:" + err.Error())
@@ -197,7 +198,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-	err = s.Update(ctx, []*relation.User{user})
+	err = s.Update(ctx, []*table.UserModel{user})
 	if err != nil {
 		return nil, err
 	}
@@ -213,11 +214,11 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	}
 	go func() {
 		for _, v := range rpcResp.FriendsInfo {
-			chat.FriendInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
+			chat.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
 		}
 	}()
 
-	chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
+	chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
 	if req.UserInfo.FaceURL != "" {
 		s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
 	}
@@ -235,13 +236,13 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.Se
 	if err != nil {
 		return nil, err
 	}
-	chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserID, req.UserID)
+	chat.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
 	return &resp, nil
 }
 
 func (s *userServer) AccountCheck(ctx context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
 	resp := pbUser.AccountCheckResp{}
-	err := token_verify.CheckManagerUserID(ctx, tracelog.GetOpUserID(ctx))
+	err := token_verify.CheckAdmin(ctx)
 	if err != nil {
 		return nil, err
 	}