errcode

internal/common/convert/convert.go

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

internal/cron_task/cron_task.go

@@ -45,11 +45,6 @@ func StartCronTask(userID, workingGroupID string) {
 	}
 }
 
-type CronTask struct {
-	spec           string
-	groupInterface controller.GroupInterface
-	userInterface  controller.UserInterface
-}
 
 func getCronTaskOperationID() string {
 	return cronTaskOperationID + utils.OperationIDGenerator()

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/table"
+	"Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tracelog"
 	pbFriend "Open_IM/pkg/proto/friend"
@@ -45,7 +45,7 @@ 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, []*table.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
+	if err := s.BlackInterface.Delete(ctx, []*relation.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
 		return nil, err
 	}
 	chat.BlackDeletedNotification(ctx, req)
@@ -57,8 +57,8 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
 		return nil, err
 	}
-	black := table.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
-	if err := s.BlackInterface.Create(ctx, []*table.BlackModel{&black}); err != nil {
+	black := relation.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
+	if err := s.BlackInterface.Create(ctx, []*relation.BlackModel{&black}); err != nil {
 		return nil, err
 	}
 	chat.BlackAddedNotification(ctx, req)

internal/rpc/friend/friend.go

@@ -7,7 +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"
+	relation2 "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/middleware"
 	promePkg "Open_IM/pkg/common/prometheus"
@@ -64,16 +64,16 @@ func NewFriendServer(port int) *friendServer {
 	//mysql init
 	var mysql relation.Mysql
 	var model relation.FriendGorm
-	err = mysql.InitConn().AutoMigrateModel(&table.FriendModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relation2.FriendModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
-	err = mysql.InitConn().AutoMigrateModel(&table.FriendRequestModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relation2.FriendRequestModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
 
-	err = mysql.InitConn().AutoMigrateModel(&table.BlackModel{})
+	err = mysql.InitConn().AutoMigrateModel(&relation2.BlackModel{})
 	if err != nil {
 		panic("db init err:" + err.Error())
 	}
@@ -166,9 +166,9 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbFriend.ImportFr
 		return nil, err
 	}
 
-	var friends []*table.FriendModel
+	var friends []*relation2.FriendModel
 	for _, userID := range utils.RemoveDuplicateElement(req.FriendUserIDs) {
-		friends = append(friends, &table.FriendModel{OwnerUserID: userID, FriendUserID: req.OwnerUserID, AddSource: constant.BecomeFriendByImport, OperatorUserID: tracelog.GetOpUserID(ctx)})
+		friends = append(friends, &relation2.FriendModel{OwnerUserID: userID, FriendUserID: req.OwnerUserID, AddSource: constant.BecomeFriendByImport, OperatorUserID: tracelog.GetOpUserID(ctx)})
 	}
 	if len(friends) > 0 {
 		if err := s.FriendInterface.BecomeFriend(ctx, friends); err != nil {
@@ -184,7 +184,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
 	if err := check.Access(ctx, req.ToUserID); err != nil {
 		return nil, err
 	}
-	friendRequest := table.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
+	friendRequest := relation2.FriendRequestModel{FromUserID: req.FromUserID, ToUserID: req.ToUserID, HandleMsg: req.HandleMsg, HandleResult: req.HandleResult}
 	if req.HandleResult == constant.FriendResponseAgree {
 		err := s.AgreeFriendRequest(ctx, &friendRequest)
 		if err != nil {

internal/rpc/group/group.go

@@ -8,7 +8,7 @@ import (
 	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/db/relation"
-	"Open_IM/pkg/common/db/table"
+	relation2 "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/db/unrelation"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/middleware"
@@ -76,7 +76,7 @@ func NewGroupServer(port int) *groupServer {
 	//mysql init
 	var mysql relation.Mysql
 	var mongo unrelation.Mongo
-	var groupModel table.GroupModel
+	var groupModel relation2.GroupModel
 	var redis cache.RedisClient
 	err = mysql.InitConn().AutoMigrateModel(&groupModel)
 	if err != nil {
@@ -192,8 +192,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	if err := callbackBeforeCreateGroup(ctx, req); err != nil {
 		return nil, err
 	}
-	var group table.GroupModel
-	var groupMembers []*table.GroupMemberModel
+	var group relation2.GroupModel
+	var groupMembers []*relation2.GroupMemberModel
 	utils.CopyStructFields(&group, req.GroupInfo)
 	group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
 	if req.GroupInfo.GroupType == constant.SuperGroup {
@@ -203,7 +203,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 	} else {
 		joinGroup := func(userID string, roleLevel int32) error {
 			user := userMap[userID]
-			groupMember := &table.GroupMemberModel{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
+			groupMember := &relation2.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
@@ -225,7 +225,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			}
 		}
 	}
-	if err := s.GroupInterface.CreateGroup(ctx, []*table.GroupModel{&group}, groupMembers); err != nil {
+	if err := s.GroupInterface.CreateGroup(ctx, []*relation2.GroupModel{&group}, groupMembers); err != nil {
 		return nil, err
 	}
 	utils.CopyStructFields(resp.GroupInfo, group)
@@ -301,7 +301,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if err != nil {
 		return nil, err
 	}
-	memberMap := make(map[string]*table.GroupMemberModel)
+	memberMap := make(map[string]*relation2.GroupMemberModel)
 	for i, member := range members {
 		memberMap[member.GroupID] = members[i]
 	}
@@ -327,9 +327,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 []*table.GroupRequestModel
+				var requests []*relation2.GroupRequestModel
 				for _, userID := range req.InvitedUserIDs {
-					requests = append(requests, &table.GroupRequestModel{
+					requests = append(requests, &relation2.GroupRequestModel{
 						UserID:        userID,
 						GroupID:       req.GroupID,
 						JoinSource:    constant.JoinByInvitation,
@@ -360,10 +360,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 		}
 	} else {
 		opUserID := tracelog.GetOpUserID(ctx)
-		var groupMembers []*table.GroupMemberModel
+		var groupMembers []*relation2.GroupMemberModel
 		for _, userID := range req.InvitedUserIDs {
 			user := userMap[userID]
-			var member table.GroupMemberModel
+			var member relation2.GroupMemberModel
 			utils.CopyStructFields(&member, user)
 			member.GroupID = req.GroupID
 			member.RoleLevel = constant.GroupOrdinaryUsers
@@ -471,7 +471,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 		if err != nil {
 			return nil, err
 		}
-		memberMap := make(map[string]*table.GroupMemberModel)
+		memberMap := make(map[string]*relation2.GroupMemberModel)
 		for i, member := range members {
 			memberMap[member.UserID] = members[i]
 		}
@@ -576,7 +576,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if err != nil {
 		return nil, err
 	}
-	groupMap := make(map[string]*table.GroupModel)
+	groupMap := make(map[string]*relation2.GroupModel)
 	for i, group := range groups {
 		groupMap[group.GroupID] = groups[i]
 	}
@@ -649,7 +649,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		return nil, err
 	}
 	groupRequest := getDBGroupRequest(ctx, req)
-	if err := (&table.GroupRequestModel{}).Update(ctx, []*table.GroupRequestModel{groupRequest}); err != nil {
+	if err := (&relation2.GroupRequestModel{}).Update(ctx, []*relation2.GroupRequestModel{groupRequest}); err != nil {
 		return nil, err
 	}
 	groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
@@ -665,7 +665,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 		if err != nil {
 			return nil, err
 		}
-		err = (&table.GroupMemberModel{}).Create(ctx, []*table.GroupMemberModel{member})
+		err = (&relation2.GroupMemberModel{}).Create(ctx, []*relation2.GroupMemberModel{member})
 		if err != nil {
 			return nil, err
 		}
@@ -719,7 +719,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 				return nil, err
 			}
 			//to group member
-			groupMember := table.GroupMemberModel{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
+			groupMember := relation2.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
@@ -762,7 +762,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			return resp, nil
 		}
 	}
-	var groupRequest table.GroupRequestModel
+	var groupRequest relation2.GroupRequestModel
 	groupRequest.UserID = tracelog.GetOpUserID(ctx)
 	groupRequest.ReqMsg = req.ReqMessage
 	groupRequest.GroupID = req.GroupID
@@ -873,7 +873,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		}
 	}
 	//only administrators can set group information
-	var groupInfo table.GroupModel
+	var groupInfo relation2.GroupModel
 	utils.CopyStructFields(&groupInfo, req.GroupInfoForSet)
 	if req.GroupInfoForSet.Notification != "" {
 		groupInfo.NotificationUserID = tracelog.GetOpUserID(ctx)
@@ -933,12 +933,12 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 		return nil, err
 	}
 
-	groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
+	groupMemberInfo := relation2.GroupMemberModel{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		return nil, err
 	}
-	groupMemberInfo = table.GroupMemberModel{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
+	groupMemberInfo = relation2.GroupMemberModel{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		return nil, err
@@ -1132,7 +1132,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 := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo := relation2.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 {
@@ -1167,7 +1167,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 		return nil, err
 	}
 
-	groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
+	groupMemberInfo := relation2.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
 	groupMemberInfo.MuteEndTime = time.Unix(0, 0)
 	err = relation.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
@@ -1266,7 +1266,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
 		return nil, err
 	}
 	nickName := cbReq.Nickname.Value
-	groupMemberInfo := table.GroupMemberModel{}
+	groupMemberInfo := relation2.GroupMemberModel{}
 	groupMemberInfo.UserID = req.UserID
 	groupMemberInfo.GroupID = req.GroupID
 	if nickName == "" {
@@ -1299,7 +1299,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 	if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil {
 		return nil, err
 	}
-	groupMember := table.GroupMemberModel{
+	groupMember := relation2.GroupMemberModel{
 		GroupID: req.GroupID,
 		UserID:  req.UserID,
 	}

internal/rpc/user/user.go

@@ -7,7 +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"
+	relation2 "Open_IM/pkg/common/db/table/relation"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
@@ -198,7 +198,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	if err != nil {
 		return nil, err
 	}
-	err = s.Update(ctx, []*table.UserModel{user})
+	err = s.Update(ctx, []*relation2.UserModel{user})
 	if err != nil {
 		return nil, err
 	}