feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>

pkg/common/db/relation/black_model.go

@@ -0,0 +1,62 @@
+package relation
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/ormutil"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type BlackGorm struct {
+	*MetaDB
+}
+
+func NewBlackGorm(db *gorm.DB) relation.BlackModelInterface {
+	return &BlackGorm{NewMetaDB(db, &relation.BlackModel{})}
+}
+
+func (b *BlackGorm) Create(ctx context.Context, blacks []*relation.BlackModel) (err error) {
+	return utils.Wrap(b.db(ctx).Create(&blacks).Error, "")
+}
+
+func (b *BlackGorm) Delete(ctx context.Context, blacks []*relation.BlackModel) (err error) {
+	return utils.Wrap(b.db(ctx).Delete(blacks).Error, "")
+}
+
+func (b *BlackGorm) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
+	return utils.Wrap(b.db(ctx).Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
+}
+
+func (b *BlackGorm) Update(ctx context.Context, blacks []*relation.BlackModel) (err error) {
+	return utils.Wrap(b.db(ctx).Updates(&blacks).Error, "")
+}
+
+func (b *BlackGorm) Find(ctx context.Context, blacks []*relation.BlackModel) (blackList []*relation.BlackModel, err error) {
+	var where [][]interface{}
+	for _, black := range blacks {
+		where = append(where, []interface{}{black.OwnerUserID, black.BlockUserID})
+	}
+	return blackList, utils.Wrap(b.db(ctx).Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
+}
+
+func (b *BlackGorm) Take(ctx context.Context, ownerUserID, blockUserID string) (black *relation.BlackModel, err error) {
+	black = &relation.BlackModel{}
+	return black, utils.Wrap(b.db(ctx).Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
+}
+
+func (b *BlackGorm) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.BlackModel, total int64, err error) {
+	err = b.db(ctx).Count(&total).Error
+	if err != nil {
+		return nil, 0, utils.Wrap(err, "")
+	}
+	totalUint32, blacks, err := ormutil.GormPage[relation.BlackModel](b.db(ctx).Where("owner_user_id = ?", ownerUserID), pageNumber, showNumber)
+	total = int64(totalUint32)
+	return
+}
+
+func (b *BlackGorm) FindBlackUserIDs(ctx context.Context, ownerUserID string) (blackUserIDs []string, err error) {
+	return blackUserIDs, utils.Wrap(b.db(ctx).Where("owner_user_id = ?", ownerUserID).Pluck("block_user_id", &blackUserIDs).Error, "")
+}

pkg/common/db/relation/chat_log_model.go

@@ -0,0 +1,86 @@
+package relation
+
+import (
+	"fmt"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/jinzhu/copier"
+	"google.golang.org/protobuf/proto"
+	"gorm.io/gorm"
+)
+
+type ChatLogGorm struct {
+	*MetaDB
+}
+
+func NewChatLogGorm(db *gorm.DB) relation.ChatLogModelInterface {
+	return &ChatLogGorm{NewMetaDB(db, &relation.ChatLogModel{})}
+}
+
+func (c *ChatLogGorm) Create(msg *pbMsg.MsgDataToMQ) error {
+	chatLog := new(relation.ChatLogModel)
+	copier.Copy(chatLog, msg.MsgData)
+	switch msg.MsgData.SessionType {
+	case constant.GroupChatType, constant.SuperGroupChatType:
+		chatLog.RecvID = msg.MsgData.GroupID
+	case constant.SingleChatType:
+		chatLog.RecvID = msg.MsgData.RecvID
+	}
+	if msg.MsgData.ContentType >= constant.NotificationBegin && msg.MsgData.ContentType <= constant.NotificationEnd {
+		var tips sdkws.TipsComm
+		_ = proto.Unmarshal(msg.MsgData.Content, &tips)
+		marshaler := jsonpb.Marshaler{
+			OrigName:     true,
+			EnumsAsInts:  false,
+			EmitDefaults: false,
+		}
+		chatLog.Content, _ = marshaler.MarshalToString(&tips)
+	} else {
+		chatLog.Content = string(msg.MsgData.Content)
+	}
+	chatLog.CreateTime = utils.UnixMillSecondToTime(msg.MsgData.CreateTime)
+	chatLog.SendTime = utils.UnixMillSecondToTime(msg.MsgData.SendTime)
+	return c.DB.Create(chatLog).Error
+}
+
+func (c *ChatLogGorm) GetChatLog(chatLog *relation.ChatLogModel, pageNumber, showNumber int32, contentTypeList []int32) (int64, []relation.ChatLogModel, error) {
+	mdb := c.DB.Model(chatLog)
+	if chatLog.SendTime.Unix() > 0 {
+		mdb = mdb.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
+	}
+	if chatLog.Content != "" {
+		mdb = mdb.Where(" content like ? ", fmt.Sprintf("%%%s%%", chatLog.Content))
+	}
+	if chatLog.SessionType == 1 {
+		mdb = mdb.Where("session_type = ?", chatLog.SessionType)
+	} else if chatLog.SessionType == 2 {
+		mdb = mdb.Where("session_type in (?)", []int{constant.GroupChatType, constant.SuperGroupChatType})
+	}
+	if chatLog.ContentType != 0 {
+		mdb = mdb.Where("content_type = ?", chatLog.ContentType)
+	}
+	if chatLog.SendID != "" {
+		mdb = mdb.Where("send_id = ?", chatLog.SendID)
+	}
+	if chatLog.RecvID != "" {
+		mdb = mdb.Where("recv_id = ?", chatLog.RecvID)
+	}
+	if len(contentTypeList) > 0 {
+		mdb = mdb.Where("content_type in (?)", contentTypeList)
+	}
+	var count int64
+	if err := mdb.Count(&count).Error; err != nil {
+		return 0, nil, err
+	}
+	var chatLogs []relation.ChatLogModel
+	mdb = mdb.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1)))
+	if err := mdb.Find(&chatLogs).Error; err != nil {
+		return 0, nil, err
+	}
+	return count, chatLogs, nil
+}

pkg/common/db/relation/conversation_model.go

@@ -0,0 +1,96 @@
+package relation
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type ConversationGorm struct {
+	*MetaDB
+}
+
+func NewConversationGorm(db *gorm.DB) relation.ConversationModelInterface {
+	return &ConversationGorm{NewMetaDB(db, &relation.ConversationModel{})}
+}
+
+func (c *ConversationGorm) NewTx(tx any) relation.ConversationModelInterface {
+	return &ConversationGorm{NewMetaDB(tx.(*gorm.DB), &relation.ConversationModel{})}
+}
+
+func (c *ConversationGorm) Create(ctx context.Context, conversations []*relation.ConversationModel) (err error) {
+	return utils.Wrap(c.db(ctx).Create(&conversations).Error, "")
+}
+
+func (c *ConversationGorm) Delete(ctx context.Context, groupIDs []string) (err error) {
+	return utils.Wrap(c.db(ctx).Where("group_id in (?)", groupIDs).Delete(&relation.ConversationModel{}).Error, "")
+}
+
+func (c *ConversationGorm) UpdateByMap(ctx context.Context, userIDList []string, conversationID string, args map[string]interface{}) (rows int64, err error) {
+	result := c.db(ctx).Where("owner_user_id IN (?) and  conversation_id=?", userIDList, conversationID).Updates(args)
+	return result.RowsAffected, utils.Wrap(result.Error, "")
+}
+
+func (c *ConversationGorm) Update(ctx context.Context, conversation *relation.ConversationModel) (err error) {
+	return utils.Wrap(c.db(ctx).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).Updates(conversation).Error, "")
+}
+
+func (c *ConversationGorm) Find(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []*relation.ConversationModel, err error) {
+	err = utils.Wrap(c.db(ctx).Where("owner_user_id=? and conversation_id IN (?)", ownerUserID, conversationIDs).Find(&conversations).Error, "")
+	return conversations, err
+}
+
+func (c *ConversationGorm) Take(ctx context.Context, userID, conversationID string) (conversation *relation.ConversationModel, err error) {
+	cc := &relation.ConversationModel{}
+	return cc, utils.Wrap(c.db(ctx).Where("conversation_id = ? And owner_user_id = ?", conversationID, userID).Take(cc).Error, "")
+}
+
+func (c *ConversationGorm) FindUserID(ctx context.Context, userIDs []string, conversationIDs []string) (existUserID []string, err error) {
+	return existUserID, utils.Wrap(c.db(ctx).Where(" owner_user_id IN (?) and conversation_id in (?)", userIDs, conversationIDs).Pluck("owner_user_id", &existUserID).Error, "")
+}
+
+func (c *ConversationGorm) FindConversationID(ctx context.Context, userID string, conversationIDList []string) (existConversationID []string, err error) {
+	return existConversationID, utils.Wrap(c.db(ctx).Where(" conversation_id IN (?) and owner_user_id=?", conversationIDList, userID).Pluck("conversation_id", &existConversationID).Error, "")
+}
+
+func (c *ConversationGorm) FindUserIDAllConversationID(ctx context.Context, userID string) (conversationIDList []string, err error) {
+	return conversationIDList, utils.Wrap(c.db(ctx).Where("owner_user_id=?", userID).Pluck("conversation_id", &conversationIDList).Error, "")
+}
+
+func (c *ConversationGorm) FindUserIDAllConversations(ctx context.Context, userID string) (conversations []*relation.ConversationModel, err error) {
+	return conversations, utils.Wrap(c.db(ctx).Where("owner_user_id=?", userID).Find(&conversations).Error, "")
+}
+
+func (c *ConversationGorm) FindRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) (userIDs []string, err error) {
+	return userIDs, utils.Wrap(c.db(ctx).Where("group_id = ? and recv_msg_opt = ?", groupID, constant.ReceiveNotNotifyMessage).Pluck("user_id", &userIDs).Error, "")
+}
+
+func (c *ConversationGorm) FindSuperGroupRecvMsgNotNotifyUserIDs(ctx context.Context, groupID string) (userIDs []string, err error) {
+	return userIDs, utils.Wrap(c.db(ctx).Where("group_id = ? and recv_msg_opt = ? and conversation_type = ?", groupID, constant.ReceiveNotNotifyMessage, constant.SuperGroupChatType).Pluck("user_id", &userIDs).Error, "")
+}
+
+func (c *ConversationGorm) GetUserRecvMsgOpt(ctx context.Context, ownerUserID, conversationID string) (opt int, err error) {
+	var conversation relation.ConversationModel
+	return int(conversation.RecvMsgOpt), utils.Wrap(c.db(ctx).Where("conversation_id = ? And owner_user_id = ?", conversationID, ownerUserID).Select("recv_msg_opt").Find(&conversation).Error, "")
+}
+
+func (c *ConversationGorm) GetAllConversationIDs(ctx context.Context) (conversationIDs []string, err error) {
+	return conversationIDs, utils.Wrap(c.db(ctx).Distinct("conversation_id").Pluck("conversation_id", &conversationIDs).Error, "")
+}
+
+func (c *ConversationGorm) GetUserAllHasReadSeqs(ctx context.Context, ownerUserID string) (hasReadSeqs map[string]int64, err error) {
+	var conversations []*relation.ConversationModel
+	err = utils.Wrap(c.db(ctx).Where("owner_user_id = ?", ownerUserID).Select("conversation_id", "has_read_seq").Find(&conversations).Error, "")
+	hasReadSeqs = make(map[string]int64, len(conversations))
+	// for _, conversation := range conversations {
+	// 	hasReadSeqs[conversation.ConversationID] = conversation.HasReadSeq
+	// }
+	return hasReadSeqs, err
+}
+
+func (c *ConversationGorm) GetConversationsByConversationID(ctx context.Context, conversationIDs []string) (conversations []*relation.ConversationModel, err error) {
+	return conversations, utils.Wrap(c.db(ctx).Where("conversation_id IN (?)", conversationIDs).Find(&conversations).Error, "")
+}

pkg/common/db/relation/friend_model.go

@@ -0,0 +1,97 @@
+package relation
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type FriendGorm struct {
+	*MetaDB
+}
+
+func NewFriendGorm(db *gorm.DB) relation.FriendModelInterface {
+	return &FriendGorm{NewMetaDB(db, &relation.FriendModel{})}
+}
+
+func (f *FriendGorm) NewTx(tx any) relation.FriendModelInterface {
+	return &FriendGorm{NewMetaDB(tx.(*gorm.DB), &relation.FriendModel{})}
+}
+
+// 插入多条记录
+func (f *FriendGorm) Create(ctx context.Context, friends []*relation.FriendModel) (err error) {
+	return utils.Wrap(f.db(ctx).Create(&friends).Error, "")
+}
+
+// 删除ownerUserID指定的好友
+func (f *FriendGorm) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) {
+	err = utils.Wrap(f.db(ctx).Where("owner_user_id = ? AND friend_user_id in ( ?)", ownerUserID, friendUserIDs).Delete(&relation.FriendModel{}).Error, "")
+	return err
+}
+
+// 更新ownerUserID单个好友信息 更新零值
+func (f *FriendGorm) UpdateByMap(ctx context.Context, ownerUserID string, friendUserID string, args map[string]interface{}) (err error) {
+	return utils.Wrap(f.db(ctx).Where("owner_user_id = ? AND friend_user_id = ? ", ownerUserID, friendUserID).Updates(args).Error, "")
+}
+
+// 更新好友信息的非零值
+func (f *FriendGorm) Update(ctx context.Context, friends []*relation.FriendModel) (err error) {
+	return utils.Wrap(f.db(ctx).Updates(&friends).Error, "")
+}
+
+// 更新好友备注（也支持零值 ）
+func (f *FriendGorm) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
+	if remark != "" {
+		return utils.Wrap(f.db(ctx).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "")
+	}
+	m := make(map[string]interface{}, 1)
+	m["remark"] = ""
+	return utils.Wrap(f.db(ctx).Where("owner_user_id = ?", ownerUserID).Updates(m).Error, "")
+}
+
+// 获取单个好友信息，如没找到 返回错误
+func (f *FriendGorm) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *relation.FriendModel, err error) {
+	friend = &relation.FriendModel{}
+	return friend, utils.Wrap(f.db(ctx).Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
+}
+
+// 查找好友关系，如果是双向关系，则都返回
+func (f *FriendGorm) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*relation.FriendModel, err error) {
+	return friends, utils.Wrap(f.db(ctx).Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "")
+}
+
+// 获取 owner指定的好友列表 如果有friendUserIDs不存在，也不返回错误
+func (f *FriendGorm) FindFriends(ctx context.Context, ownerUserID string, friendUserIDs []string) (friends []*relation.FriendModel, err error) {
+	return friends, utils.Wrap(f.db(ctx).Where("owner_user_id = ? AND friend_user_id in (?)", ownerUserID, friendUserIDs).Find(&friends).Error, "")
+}
+
+// 获取哪些人添加了friendUserID 如果有ownerUserIDs不存在，也不返回错误
+func (f *FriendGorm) FindReversalFriends(ctx context.Context, friendUserID string, ownerUserIDs []string) (friends []*relation.FriendModel, err error) {
+	return friends, utils.Wrap(f.db(ctx).Where("friend_user_id = ? AND owner_user_id in (?)", friendUserID, ownerUserIDs).Find(&friends).Error, "")
+}
+
+// 获取ownerUserID好友列表 支持翻页
+func (f *FriendGorm) FindOwnerFriends(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (friends []*relation.FriendModel, total int64, err error) {
+	err = f.DB.Model(&relation.FriendModel{}).Where("owner_user_id = ? ", ownerUserID).Count(&total).Error
+	if err != nil {
+		return nil, 0, utils.Wrap(err, "")
+	}
+	err = utils.Wrap(f.db(ctx).Where("owner_user_id = ? ", ownerUserID).Limit(int(showNumber)).Offset(int((pageNumber-1)*showNumber)).Find(&friends).Error, "")
+	return
+}
+
+// 获取哪些人添加了friendUserID 支持翻页
+func (f *FriendGorm) FindInWhoseFriends(ctx context.Context, friendUserID string, pageNumber, showNumber int32) (friends []*relation.FriendModel, total int64, err error) {
+	err = f.DB.Model(&relation.FriendModel{}).Where("friend_user_id = ? ", friendUserID).Count(&total).Error
+	if err != nil {
+		return nil, 0, utils.Wrap(err, "")
+	}
+	err = utils.Wrap(f.db(ctx).Where("friend_user_id = ? ", friendUserID).Limit(int(showNumber)).Offset(int((pageNumber-1)*showNumber)).Find(&friends).Error, "")
+	return
+}
+
+func (f *FriendGorm) FindFriendUserIDs(ctx context.Context, ownerUserID string) (friendUserIDs []string, err error) {
+	return friendUserIDs, utils.Wrap(f.db(ctx).Model(&relation.FriendModel{}).Where("owner_user_id = ? ", ownerUserID).Pluck("friend_user_id", &friendUserIDs).Error, "")
+}

pkg/common/db/relation/friend_request_model.go

@@ -0,0 +1,74 @@
+package relation
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type FriendRequestGorm struct {
+	*MetaDB
+}
+
+func NewFriendRequestGorm(db *gorm.DB) relation.FriendRequestModelInterface {
+	return &FriendRequestGorm{NewMetaDB(db, &relation.FriendRequestModel{})}
+}
+
+func (f *FriendRequestGorm) NewTx(tx any) relation.FriendRequestModelInterface {
+	return &FriendRequestGorm{NewMetaDB(tx.(*gorm.DB), &relation.FriendRequestModel{})}
+}
+
+// 插入多条记录
+func (f *FriendRequestGorm) Create(ctx context.Context, friendRequests []*relation.FriendRequestModel) (err error) {
+	return utils.Wrap(f.db(ctx).Create(&friendRequests).Error, "")
+}
+
+// 删除记录
+func (f *FriendRequestGorm) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
+	return utils.Wrap(f.db(ctx).Where("from_user_id = ? AND to_user_id = ?", fromUserID, toUserID).Delete(&relation.FriendRequestModel{}).Error, "")
+}
+
+// 更新零值
+func (f *FriendRequestGorm) UpdateByMap(ctx context.Context, fromUserID string, toUserID string, args map[string]interface{}) (err error) {
+	return utils.Wrap(f.db(ctx).Model(&relation.FriendRequestModel{}).Where("from_user_id = ? AND to_user_id =?", fromUserID, toUserID).Updates(args).Error, "")
+}
+
+// 更新记录 （非零值）
+func (f *FriendRequestGorm) Update(ctx context.Context, friendRequest *relation.FriendRequestModel) (err error) {
+	return utils.Wrap(f.db(ctx).Where("from_user_id = ? AND to_user_id =?", friendRequest.FromUserID, friendRequest.ToUserID).Updates(friendRequest).Error, "")
+}
+
+// 获取来指定用户的好友申请  未找到 不返回错误
+func (f *FriendRequestGorm) Find(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
+	friendRequest = &relation.FriendRequestModel{}
+	err = utils.Wrap(f.db(ctx).Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Find(friendRequest).Error, "")
+	return friendRequest, err
+}
+
+func (f *FriendRequestGorm) Take(ctx context.Context, fromUserID, toUserID string) (friendRequest *relation.FriendRequestModel, err error) {
+	friendRequest = &relation.FriendRequestModel{}
+	err = utils.Wrap(f.db(ctx).Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Take(friendRequest).Error, "")
+	return friendRequest, err
+}
+
+// 获取toUserID收到的好友申请列表
+func (f *FriendRequestGorm) FindToUserID(ctx context.Context, toUserID string, pageNumber, showNumber int32) (friendRequests []*relation.FriendRequestModel, total int64, err error) {
+	err = f.db(ctx).Model(&relation.FriendRequestModel{}).Where("to_user_id = ? ", toUserID).Count(&total).Error
+	if err != nil {
+		return nil, 0, utils.Wrap(err, "")
+	}
+	err = utils.Wrap(f.db(ctx).Where("to_user_id = ? ", toUserID).Limit(int(showNumber)).Offset(int(pageNumber-1)*int(showNumber)).Find(&friendRequests).Error, "")
+	return
+}
+
+// 获取fromUserID发出去的好友申请列表
+func (f *FriendRequestGorm) FindFromUserID(ctx context.Context, fromUserID string, pageNumber, showNumber int32) (friendRequests []*relation.FriendRequestModel, total int64, err error) {
+	err = f.db(ctx).Model(&relation.FriendRequestModel{}).Where("from_user_id = ? ", fromUserID).Count(&total).Error
+	if err != nil {
+		return nil, 0, utils.Wrap(err, "")
+	}
+	err = utils.Wrap(f.db(ctx).Where("from_user_id = ? ", fromUserID).Limit(int(showNumber)).Offset(int(pageNumber-1)*int(showNumber)).Find(&friendRequests).Error, "")
+	return
+}

pkg/common/db/relation/group_member_model.go

@@ -0,0 +1,135 @@
+package relation
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/ormutil"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+var _ relation.GroupMemberModelInterface = (*GroupMemberGorm)(nil)
+
+type GroupMemberGorm struct {
+	*MetaDB
+}
+
+func NewGroupMemberDB(db *gorm.DB) relation.GroupMemberModelInterface {
+	return &GroupMemberGorm{NewMetaDB(db, &relation.GroupMemberModel{})}
+}
+
+func (g *GroupMemberGorm) NewTx(tx any) relation.GroupMemberModelInterface {
+	return &GroupMemberGorm{NewMetaDB(tx.(*gorm.DB), &relation.GroupMemberModel{})}
+}
+
+func (g *GroupMemberGorm) Create(ctx context.Context, groupMemberList []*relation.GroupMemberModel) (err error) {
+	return utils.Wrap(g.db(ctx).Create(&groupMemberList).Error, "")
+}
+
+func (g *GroupMemberGorm) Delete(ctx context.Context, groupID string, userIDs []string) (err error) {
+	return utils.Wrap(g.db(ctx).Where("group_id = ? and user_id in (?)", groupID, userIDs).Delete(&relation.GroupMemberModel{}).Error, "")
+}
+
+func (g *GroupMemberGorm) DeleteGroup(ctx context.Context, groupIDs []string) (err error) {
+	return utils.Wrap(g.db(ctx).Where("group_id in (?)", groupIDs).Delete(&relation.GroupMemberModel{}).Error, "")
+}
+
+func (g *GroupMemberGorm) Update(ctx context.Context, groupID string, userID string, data map[string]any) (err error) {
+	return utils.Wrap(g.db(ctx).Where("group_id = ? and user_id = ?", groupID, userID).Updates(data).Error, "")
+}
+
+func (g *GroupMemberGorm) UpdateRoleLevel(ctx context.Context, groupID string, userID string, roleLevel int32) (rowsAffected int64, err error) {
+	db := g.db(ctx).Where("group_id = ? and user_id = ?", groupID, userID).Updates(map[string]any{
+		"role_level": roleLevel,
+	})
+	return db.RowsAffected, utils.Wrap(db.Error, "")
+}
+
+func (g *GroupMemberGorm) Find(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) (groupMembers []*relation.GroupMemberModel, err error) {
+	db := g.db(ctx)
+	if len(groupIDs) > 0 {
+		db = db.Where("group_id in (?)", groupIDs)
+	}
+	if len(userIDs) > 0 {
+		db = db.Where("user_id in (?)", userIDs)
+	}
+	if len(roleLevels) > 0 {
+		db = db.Where("role_level in (?)", roleLevels)
+	}
+	return groupMembers, utils.Wrap(db.Find(&groupMembers).Error, "")
+}
+
+func (g *GroupMemberGorm) Take(ctx context.Context, groupID string, userID string) (groupMember *relation.GroupMemberModel, err error) {
+	groupMember = &relation.GroupMemberModel{}
+	return groupMember, utils.Wrap(g.db(ctx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
+}
+
+func (g *GroupMemberGorm) TakeOwner(ctx context.Context, groupID string) (groupMember *relation.GroupMemberModel, err error) {
+	groupMember = &relation.GroupMemberModel{}
+	return groupMember, utils.Wrap(g.db(ctx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "")
+}
+
+func (g *GroupMemberGorm) SearchMember(ctx context.Context, keyword string, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (total uint32, groupList []*relation.GroupMemberModel, err error) {
+	db := g.db(ctx)
+	ormutil.GormIn(&db, "group_id", groupIDs)
+	ormutil.GormIn(&db, "user_id", userIDs)
+	ormutil.GormIn(&db, "role_level", roleLevels)
+	return ormutil.GormSearch[relation.GroupMemberModel](db, []string{"nickname"}, keyword, pageNumber, showNumber)
+}
+
+func (g *GroupMemberGorm) MapGroupMemberNum(ctx context.Context, groupIDs []string) (count map[string]uint32, err error) {
+	return ormutil.MapCount(g.db(ctx).Where("group_id in (?)", groupIDs), "group_id")
+}
+
+func (g *GroupMemberGorm) FindJoinUserID(ctx context.Context, groupIDs []string) (groupUsers map[string][]string, err error) {
+	var groupMembers []*relation.GroupMemberModel
+	if err := g.db(ctx).Select("group_id, user_id").Where("group_id in (?)", groupIDs).Find(&groupMembers).Error; err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	groupUsers = make(map[string][]string)
+	for _, item := range groupMembers {
+		v, ok := groupUsers[item.GroupID]
+		if !ok {
+			groupUsers[item.GroupID] = []string{item.UserID}
+		} else {
+			groupUsers[item.GroupID] = append(v, item.UserID)
+		}
+	}
+	return groupUsers, nil
+}
+
+func (g *GroupMemberGorm) FindMemberUserID(ctx context.Context, groupID string) (userIDs []string, err error) {
+	return userIDs, utils.Wrap(g.db(ctx).Where("group_id = ?", groupID).Pluck("user_id", &userIDs).Error, "")
+}
+
+func (g *GroupMemberGorm) FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
+	return groupIDs, utils.Wrap(g.db(ctx).Where("user_id = ?", userID).Pluck("group_id", &groupIDs).Error, "")
+}
+
+func (g *GroupMemberGorm) TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error) {
+	return count, utils.Wrap(g.db(ctx).Where("group_id = ?", groupID).Count(&count).Error, "")
+}
+
+func (g *GroupMemberGorm) FindUsersJoinedGroupID(ctx context.Context, userIDs []string) (map[string][]string, error) {
+	var groupMembers []*relation.GroupMemberModel
+	err := g.db(ctx).Select("group_id, user_id").Where("user_id IN (?)", userIDs).Find(&groupMembers).Error
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string][]string)
+	for _, groupMember := range groupMembers {
+		v, ok := result[groupMember.UserID]
+		if !ok {
+			result[groupMember.UserID] = []string{groupMember.GroupID}
+		} else {
+			result[groupMember.UserID] = append(v, groupMember.GroupID)
+		}
+	}
+	return result, nil
+}
+
+func (g *GroupMemberGorm) FindUserManagedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
+	return groupIDs, utils.Wrap(g.db(ctx).Model(&relation.GroupMemberModel{}).Where("user_id = ? and (role_level = ? or role_level = ?)", userID, constant.GroupOwner, constant.GroupAdmin).Pluck("group_id", &groupIDs).Error, "")
+}

pkg/common/db/relation/group_model.go

@@ -0,0 +1,52 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/ormutil"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+var _ relation.GroupModelInterface = (*GroupGorm)(nil)
+
+type GroupGorm struct {
+	*MetaDB
+}
+
+func NewGroupDB(db *gorm.DB) relation.GroupModelInterface {
+	return &GroupGorm{NewMetaDB(db, &relation.GroupModel{})}
+}
+
+func (g *GroupGorm) NewTx(tx any) relation.GroupModelInterface {
+	return &GroupGorm{NewMetaDB(tx.(*gorm.DB), &relation.GroupModel{})}
+}
+
+func (g *GroupGorm) Create(ctx context.Context, groups []*relation.GroupModel) (err error) {
+	return utils.Wrap(g.DB.Create(&groups).Error, "")
+}
+
+func (g *GroupGorm) UpdateMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) {
+	return utils.Wrap(g.DB.Where("group_id = ?", groupID).Model(&relation.GroupModel{}).Updates(args).Error, "")
+}
+
+func (g *GroupGorm) UpdateStatus(ctx context.Context, groupID string, status int32) (err error) {
+	return utils.Wrap(g.DB.Where("group_id = ?", groupID).Model(&relation.GroupModel{}).Updates(map[string]any{"status": status}).Error, "")
+}
+
+func (g *GroupGorm) Find(ctx context.Context, groupIDs []string) (groups []*relation.GroupModel, err error) {
+	return groups, utils.Wrap(g.DB.Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
+}
+
+func (g *GroupGorm) Take(ctx context.Context, groupID string) (group *relation.GroupModel, err error) {
+	group = &relation.GroupModel{}
+	return group, utils.Wrap(g.DB.Where("group_id = ?", groupID).Take(group).Error, "")
+}
+
+func (g *GroupGorm) Search(ctx context.Context, keyword string, pageNumber, showNumber int32) (total uint32, groups []*relation.GroupModel, err error) {
+	return ormutil.GormSearch[relation.GroupModel](g.DB, []string{"name"}, keyword, pageNumber, showNumber)
+}
+
+func (g *GroupGorm) GetGroupIDsByGroupType(ctx context.Context, groupType int) (groupIDs []string, err error) {
+	return groupIDs, utils.Wrap(g.DB.Model(&relation.GroupModel{}).Where("group_type = ? ", groupType).Pluck("group_id", &groupIDs).Error, "")
+}

pkg/common/db/relation/group_request_model.go

@@ -0,0 +1,52 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/ormutil"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type GroupRequestGorm struct {
+	*MetaDB
+}
+
+func NewGroupRequest(db *gorm.DB) relation.GroupRequestModelInterface {
+	return &GroupRequestGorm{
+		NewMetaDB(db, &relation.GroupRequestModel{}),
+	}
+}
+
+func (g *GroupRequestGorm) NewTx(tx any) relation.GroupRequestModelInterface {
+	return &GroupRequestGorm{NewMetaDB(tx.(*gorm.DB), &relation.GroupRequestModel{})}
+}
+
+func (g *GroupRequestGorm) Create(ctx context.Context, groupRequests []*relation.GroupRequestModel) (err error) {
+	return utils.Wrap(g.DB.WithContext(ctx).Create(&groupRequests).Error, utils.GetSelfFuncName())
+}
+
+func (g *GroupRequestGorm) Delete(ctx context.Context, groupID string, userID string) (err error) {
+	return utils.Wrap(g.DB.WithContext(ctx).Where("group_id = ? and user_id = ? ", groupID, userID).Delete(&relation.GroupRequestModel{}).Error, utils.GetSelfFuncName())
+}
+
+func (g *GroupRequestGorm) UpdateHandler(ctx context.Context, groupID string, userID string, handledMsg string, handleResult int32) (err error) {
+	return utils.Wrap(g.DB.WithContext(ctx).Model(&relation.GroupRequestModel{}).Where("group_id = ? and user_id = ? ", groupID, userID).Updates(map[string]any{
+		"handle_msg":    handledMsg,
+		"handle_result": handleResult,
+	}).Error, utils.GetSelfFuncName())
+}
+
+func (g *GroupRequestGorm) Take(ctx context.Context, groupID string, userID string) (groupRequest *relation.GroupRequestModel, err error) {
+	groupRequest = &relation.GroupRequestModel{}
+	return groupRequest, utils.Wrap(g.DB.WithContext(ctx).Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
+}
+
+func (g *GroupRequestGorm) Page(ctx context.Context, userID string, pageNumber, showNumber int32) (total uint32, groups []*relation.GroupRequestModel, err error) {
+	return ormutil.GormSearch[relation.GroupRequestModel](g.DB.WithContext(ctx).Where("user_id = ?", userID), nil, "", pageNumber, showNumber)
+}
+
+func (g *GroupRequestGorm) PageGroup(ctx context.Context, groupIDs []string, pageNumber, showNumber int32) (total uint32, groups []*relation.GroupRequestModel, err error) {
+	return ormutil.GormPage[relation.GroupRequestModel](g.DB.WithContext(ctx).Where("group_id in ?", groupIDs), pageNumber, showNumber)
+}

pkg/common/db/relation/meta_db.go

@@ -0,0 +1,23 @@
+package relation
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+)
+
+type MetaDB struct {
+	DB    *gorm.DB
+	table any
+}
+
+func NewMetaDB(db *gorm.DB, table any) *MetaDB {
+	return &MetaDB{
+		DB:    db,
+		table: table,
+	}
+}
+
+func (g *MetaDB) db(ctx context.Context) *gorm.DB {
+	return g.DB.WithContext(ctx).Model(g.table)
+}

pkg/common/db/relation/mysql_init.go

@@ -0,0 +1,76 @@
+package relation
+
+import (
+	"fmt"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mw/specialerror"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	mysqlDriver "github.com/go-sql-driver/mysql"
+	"gorm.io/driver/mysql"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func newMysqlGormDB() (*gorm.DB, error) {
+	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
+		config.Config.Mysql.Username, config.Config.Mysql.Password, config.Config.Mysql.Address[0], "mysql")
+	db, err := gorm.Open(mysql.Open(dsn), nil)
+	if err != nil {
+		time.Sleep(time.Duration(30) * time.Second)
+		db, err = gorm.Open(mysql.Open(dsn), nil)
+		if err != nil {
+			panic(err.Error() + " open failed " + dsn)
+		}
+	}
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+	defer sqlDB.Close()
+	sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8mb4 COLLATE utf8mb4_unicode_ci;", config.Config.Mysql.Database)
+	err = db.Exec(sql).Error
+	if err != nil {
+		return nil, fmt.Errorf("init db %w", err)
+	}
+	dsn = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
+		config.Config.Mysql.Username, config.Config.Mysql.Password, config.Config.Mysql.Address[0], config.Config.Mysql.Database)
+	sqlLogger := log.NewSqlLogger(logger.LogLevel(config.Config.Mysql.LogLevel), true, time.Duration(config.Config.Mysql.SlowThreshold)*time.Millisecond)
+	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: sqlLogger,
+	})
+	if err != nil {
+		return nil, err
+	}
+	sqlDB, err = db.DB()
+	if err != nil {
+		return nil, err
+	}
+	sqlDB.SetConnMaxLifetime(time.Second * time.Duration(config.Config.Mysql.MaxLifeTime))
+	sqlDB.SetMaxOpenConns(config.Config.Mysql.MaxOpenConn)
+	sqlDB.SetMaxIdleConns(config.Config.Mysql.MaxIdleConn)
+	return db, nil
+}
+
+// gorm mysql
+func NewGormDB() (*gorm.DB, error) {
+	specialerror.AddReplace(gorm.ErrRecordNotFound, errs.ErrRecordNotFound)
+	specialerror.AddErrHandler(replaceDuplicateKey)
+	return newMysqlGormDB()
+}
+
+func replaceDuplicateKey(err error) errs.CodeError {
+	if IsMysqlDuplicateKey(err) {
+		return errs.ErrDuplicateKey
+	}
+	return nil
+}
+
+func IsMysqlDuplicateKey(err error) bool {
+	if mysqlErr, ok := err.(*mysqlDriver.MySQLError); ok {
+		return mysqlErr.Number == 1062
+	}
+	return false
+}

pkg/common/db/relation/object_hash_model.go

@@ -0,0 +1,42 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type ObjectHashGorm struct {
+	*MetaDB
+}
+
+func NewObjectHash(db *gorm.DB) relation.ObjectHashModelInterface {
+	return &ObjectHashGorm{
+		NewMetaDB(db, &relation.ObjectHashModel{}),
+	}
+}
+
+func (o *ObjectHashGorm) NewTx(tx any) relation.ObjectHashModelInterface {
+	return &ObjectHashGorm{
+		NewMetaDB(tx.(*gorm.DB), &relation.ObjectHashModel{}),
+	}
+}
+
+func (o *ObjectHashGorm) Take(ctx context.Context, hash string, engine string) (oh *relation.ObjectHashModel, err error) {
+	oh = &relation.ObjectHashModel{}
+	return oh, utils.Wrap1(o.DB.Where("hash = ? and engine = ?", hash, engine).Take(oh).Error)
+}
+
+func (o *ObjectHashGorm) Create(ctx context.Context, h []*relation.ObjectHashModel) (err error) {
+	return utils.Wrap1(o.DB.Create(h).Error)
+}
+
+func (o *ObjectHashGorm) DeleteNoCitation(ctx context.Context, engine string, num int) (list []*relation.ObjectHashModel, err error) {
+	err = o.DB.Table(relation.ObjectHashModelTableName, "as h").Select("h.*").
+		Joins("LEFT JOIN "+relation.ObjectInfoModelTableName+" as i ON h.hash = i.hash").
+		Where("h.engine = ? AND i.hash IS NULL", engine).
+		Limit(num).
+		Find(&list).Error
+	return list, utils.Wrap1(err)
+}

pkg/common/db/relation/object_info_model.go

@@ -0,0 +1,48 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+	"time"
+)
+
+type ObjectInfoGorm struct {
+	*MetaDB
+}
+
+func NewObjectInfo(db *gorm.DB) relation.ObjectInfoModelInterface {
+	return &ObjectInfoGorm{
+		NewMetaDB(db, &relation.ObjectInfoModel{}),
+	}
+}
+
+func (o *ObjectInfoGorm) NewTx(tx any) relation.ObjectInfoModelInterface {
+	return &ObjectInfoGorm{
+		NewMetaDB(tx.(*gorm.DB), &relation.ObjectInfoModel{}),
+	}
+}
+
+func (o *ObjectInfoGorm) SetObject(ctx context.Context, obj *relation.ObjectInfoModel) (err error) {
+	if err := o.DB.WithContext(ctx).Where("name = ?", obj.Name).Delete(&relation.ObjectInfoModel{}).Error; err != nil {
+		return errs.Wrap(err)
+	}
+	return errs.Wrap(o.DB.WithContext(ctx).Create(obj).Error)
+	//return errs.Wrap(o.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+	//	if err := tx.Where("name = ?", obj.Name).Delete(&relation.ObjectInfoModel{}).Error; err != nil {
+	//		return errs.Wrap(err)
+	//	}
+	//	return errs.Wrap(tx.Create(obj).Error)
+	//}))
+}
+
+func (o *ObjectInfoGorm) Take(ctx context.Context, name string) (info *relation.ObjectInfoModel, err error) {
+	info = &relation.ObjectInfoModel{}
+	return info, utils.Wrap1(o.DB.WithContext(ctx).Where("name = ?", name).Take(info).Error)
+}
+
+func (o *ObjectInfoGorm) DeleteExpiration(ctx context.Context, expiration time.Time) (err error) {
+	return utils.Wrap1(o.DB.WithContext(ctx).Where("expiration_time IS NOT NULL AND expiration_time <= ?", expiration).Delete(&relation.ObjectInfoModel{}).Error)
+}

pkg/common/db/relation/object_put_model.go

@@ -0,0 +1,47 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+	"time"
+)
+
+type ObjectPutGorm struct {
+	*MetaDB
+}
+
+func NewObjectPut(db *gorm.DB) relation.ObjectPutModelInterface {
+	return &ObjectPutGorm{
+		NewMetaDB(db, &relation.ObjectPutModel{}),
+	}
+}
+
+func (o *ObjectPutGorm) NewTx(tx any) relation.ObjectPutModelInterface {
+	return &ObjectPutGorm{
+		NewMetaDB(tx.(*gorm.DB), &relation.ObjectPutModel{}),
+	}
+}
+
+func (o *ObjectPutGorm) Create(ctx context.Context, m []*relation.ObjectPutModel) (err error) {
+	return utils.Wrap1(o.DB.Create(m).Error)
+}
+
+func (o *ObjectPutGorm) Take(ctx context.Context, putID string) (put *relation.ObjectPutModel, err error) {
+	put = &relation.ObjectPutModel{}
+	return put, utils.Wrap1(o.DB.Where("put_id = ?", putID).Take(put).Error)
+}
+
+func (o *ObjectPutGorm) SetCompleted(ctx context.Context, putID string) (err error) {
+	return utils.Wrap1(o.DB.Model(&relation.ObjectPutModel{}).Where("put_id = ?", putID).Update("complete", true).Error)
+}
+
+func (o *ObjectPutGorm) FindExpirationPut(ctx context.Context, expirationTime time.Time, num int) (list []*relation.ObjectPutModel, err error) {
+	err = o.DB.Where("effective_time <= ?", expirationTime).Limit(num).Find(&list).Error
+	return list, utils.Wrap1(err)
+}
+
+func (o *ObjectPutGorm) DelPut(ctx context.Context, ids []string) (err error) {
+	return utils.Wrap1(o.DB.Where("put_id IN ?", ids).Delete(&relation.ObjectPutModel{}).Error)
+}

pkg/common/db/relation/user_model.go

@@ -0,0 +1,89 @@
+package relation
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+	"gorm.io/gorm"
+)
+
+type UserGorm struct {
+	*MetaDB
+}
+
+func NewUserGorm(db *gorm.DB) relation.UserModelInterface {
+	return &UserGorm{NewMetaDB(db, &relation.UserModel{})}
+}
+
+// 插入多条
+func (u *UserGorm) Create(ctx context.Context, users []*relation.UserModel) (err error) {
+	return utils.Wrap(u.db(ctx).Create(&users).Error, "")
+}
+
+// 更新用户信息 零值
+func (u *UserGorm) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
+	return utils.Wrap(u.db(ctx).Where("user_id = ?", userID).Updates(args).Error, "")
+}
+
+// 更新多个用户信息 非零值
+func (u *UserGorm) Update(ctx context.Context, user *relation.UserModel) (err error) {
+	return utils.Wrap(u.db(ctx).Model(user).Updates(user).Error, "")
+}
+
+// 获取指定用户信息  不存在，也不返回错误
+func (u *UserGorm) Find(ctx context.Context, userIDs []string) (users []*relation.UserModel, err error) {
+	err = utils.Wrap(u.db(ctx).Where("user_id in (?)", userIDs).Find(&users).Error, "")
+	return users, err
+}
+
+// 获取某个用户信息  不存在，则返回错误
+func (u *UserGorm) Take(ctx context.Context, userID string) (user *relation.UserModel, err error) {
+	user = &relation.UserModel{}
+	err = utils.Wrap(u.db(ctx).Where("user_id = ?", userID).Take(&user).Error, "")
+	return user, err
+}
+
+// 获取用户信息 不存在，不返回错误
+func (u *UserGorm) Page(ctx context.Context, pageNumber, showNumber int32) (users []*relation.UserModel, count int64, err error) {
+	err = utils.Wrap(u.db(ctx).Count(&count).Error, "")
+	if err != nil {
+		return
+	}
+	err = utils.Wrap(u.db(ctx).Limit(int(showNumber)).Offset(int((pageNumber-1)*showNumber)).Find(&users).Order("create_time DESC").Error, "")
+	return
+}
+
+// 获取所有用户ID
+func (u *UserGorm) GetAllUserID(ctx context.Context) (userIDs []string, err error) {
+	err = u.db(ctx).Pluck("user_id", &userIDs).Error
+	return userIDs, err
+}
+
+func (u *UserGorm) GetUserGlobalRecvMsgOpt(ctx context.Context, userID string) (opt int, err error) {
+	err = u.db(ctx).Model(&relation.UserModel{}).Where("user_id = ?", userID).Pluck("global_recv_msg_opt", &opt).Error
+	return opt, err
+}
+
+func (u *UserGorm) CountTotal(ctx context.Context) (count int64, err error) {
+	err = u.db(ctx).Model(&relation.UserModel{}).Count(&count).Error
+	return count, errs.Wrap(err)
+}
+
+func (u *UserGorm) CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error) {
+	var res []struct {
+		Date  string `gorm:"column:date"`
+		Count int64  `gorm:"column:count"`
+	}
+	err := u.db(ctx).Model(&relation.UserModel{}).Select("DATE(create_time) AS date, count(1) AS count").Where("create_time >= ? and create_time < ?", start, end).Group("date").Find(&res).Error
+	if err != nil {
+		return nil, errs.Wrap(err)
+	}
+	v := make(map[string]int64)
+	for _, r := range res {
+		v[r.Date] = r.Count
+	}
+	return v, nil
+}