Merge remote-tracking branch 'origin/errcode' into errcode

# Conflicts:
#	internal/utils/convert.go

pkg/common/db/relation/chat_log_model.go

@@ -14,8 +14,6 @@ import (
 	"time"
 )
 
-var ChatLogDB *gorm.DB
-
 type ChatLog struct {
 	ServerMsgID      string    `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"`
 	ClientMsgID      string    `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"`
@@ -32,6 +30,7 @@ type ChatLog struct {
 	SendTime         time.Time `gorm:"column:send_time;index:sendTime;index:content_type,priority:1;index:session_type,priority:1;index:recv_id,priority:1;index:send_id,priority:1" json:"sendTime"`
 	CreateTime       time.Time `gorm:"column:create_time" json:"createTime"`
 	Ex               string    `gorm:"column:ex;type:varchar(1024)" json:"ex"`
+	DB               *gorm.DB
 }
 
 func (ChatLog) TableName() string {

pkg/common/db/relation/group_member_model_k.go

@@ -24,36 +24,40 @@ type GroupMember struct {
 	OperatorUserID string    `gorm:"column:operator_user_id;size:64"`
 	MuteEndTime    time.Time `gorm:"column:mute_end_time"`
 	Ex             string    `gorm:"column:ex;size:1024"`
-	DB             *gorm.DB
+	DB             *gorm.DB  `gorm:"-" json:"-"`
 }
 
-func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) {
+func NewGroupMemberDB(db *gorm.DB) *GroupMember {
+	return &GroupMember{DB: db}
+}
+
+func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
 	}()
-	return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Create(&groupMemberList).Error, "")
 }
 
-func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) {
+func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
 	}()
-	return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Delete(groupMembers).Error, "")
 }
 
-func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
+func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
 	}()
-	return utils.Wrap(GroupMemberDB.Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
 }
 
-func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember) (err error) {
+func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
-	return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "")
+	return utils.Wrap(getDBConn(g.DB, tx).Updates(&groupMembers).Error, "")
 }
 
-func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) {
+func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (groupList []*GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
 	}()
@@ -61,25 +65,23 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (gr
 	for _, groupMember := range groupMembers {
 		where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
 	}
-	err = utils.Wrap(GroupMemberDB.Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
-	return groupList, err
+	return groupList, utils.Wrap(getDBConn(g.DB, tx).Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
 }
 
-func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMember, err error) {
+func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
-	return groupMember, utils.Wrap(GroupMemberDB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
+	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
 }
 
-func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) {
+func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
-	err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error
-	return groupMember, utils.Wrap(err, "")
+	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "")
 }
 
 func InsertIntoGroupMember(toInsertInfo GroupMember) error {

pkg/common/db/relation/group_model_k.go

@@ -37,8 +37,7 @@ func (g *Group) Create(ctx context.Context, groups []*Group, tx ...*gorm.DB) (er
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
 	}()
-	err = utils.Wrap(getDBConn(g.DB, tx).Create(&groups).Error, "")
-	return err
+	return utils.Wrap(getDBConn(g.DB, tx).Create(&groups).Error, "")
 }
 
 func (g *Group) Delete(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (err error) {
@@ -66,8 +65,7 @@ func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (gr
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups)
 	}()
-	err = utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
-	return groups, err
+	return groups, utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
 }
 
 func (g *Group) Take(ctx context.Context, groupID string, tx ...*gorm.DB) (group *Group, err error) {
@@ -75,8 +73,7 @@ func (g *Group) Take(ctx context.Context, groupID string, tx ...*gorm.DB) (group
 	defer func() {
 		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
 	}()
-	err = utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Take(group).Error, "")
-	return group, err
+	return group, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Take(group).Error, "")
 }
 
 //func (g *Group) DeleteTx(ctx context.Context, groupIDs []string) error {

pkg/common/db/relation/group_request_model_k.go

@@ -22,6 +22,13 @@ type GroupRequest struct {
 	JoinSource    int32     `gorm:"column:join_source"`
 	InviterUserID string    `gorm:"column:inviter_user_id;size:64"`
 	Ex            string    `gorm:"column:ex;size:1024"`
+	DB            *gorm.DB
+}
+
+func NewGroupRequest(db *gorm.DB) *GroupRequest {
+	return &GroupRequest{
+		DB: db,
+	}
 }
 
 func (GroupRequest) TableName() string {

pkg/common/db/relation/statistics_model.go

@@ -2,61 +2,73 @@ package relation
 
 import (
 	"Open_IM/pkg/common/constant"
+	"gorm.io/gorm"
 	"time"
 )
 
-func GetActiveUserNum(from, to time.Time) (int32, error) {
-	var num int64
-	err := ChatLogDB.Table("chat_logs").Select("count(distinct(send_id))").Where("send_time >= ? and send_time <= ?", from, to).Count(&num).Error
-	return int32(num), err
+type Statistics struct {
+	DB *gorm.DB
 }
 
-func GetIncreaseUserNum(from, to time.Time) (int32, error) {
-	var num int64
-	err := UserDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
-	return int32(num), err
+func NewStatistics(db *gorm.DB) *Statistics {
+	return &Statistics{DB: db}
 }
 
-func GetTotalUserNum() (int32, error) {
-	var num int64
-	err := UserDB.Count(&num).Error
-	return int32(num), err
+func (s *Statistics) getUserModel() *gorm.DB {
+	return s.DB.Model(&User{})
 }
 
-func GetTotalUserNumByDate(to time.Time) (int32, error) {
-	var num int64
-	err := UserDB.Where("create_time <= ?", to).Count(&num).Error
-	return int32(num), err
+func (s *Statistics) getChatLogModel() *gorm.DB {
+	return s.DB.Model(&ChatLog{})
 }
 
-func GetPrivateMessageNum(from, to time.Time) (int32, error) {
-	var num int64
-	err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 1).Count(&num).Error
-	return int32(num), err
+func (s *Statistics) getGroupModel() *gorm.DB {
+	return s.DB.Model(&Group{})
 }
 
-func GetGroupMessageNum(from, to time.Time) (int32, error) {
-	var num int64
-	err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 2).Count(&num).Error
-	return int32(num), err
+func (s *Statistics) GetActiveUserNum(from, to time.Time) (num int64, err error) {
+	err = s.getChatLogModel().Select("count(distinct(send_id))").Where("send_time >= ? and send_time <= ?", from, to).Count(&num).Error
+	return num, err
 }
 
-func GetIncreaseGroupNum(from, to time.Time) (int32, error) {
-	var num int64
-	err := GroupDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
-	return int32(num), err
+func (s *Statistics) GetIncreaseUserNum(from, to time.Time) (num int64, err error) {
+	err = s.getUserModel().Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
+	return num, err
 }
 
-func GetTotalGroupNum() (int32, error) {
-	var num int64
-	err := GroupDB.Count(&num).Error
-	return int32(num), err
+func (s *Statistics) GetTotalUserNum() (num int64, err error) {
+	err = s.getUserModel().Count(&num).Error
+	return num, err
 }
 
-func GetGroupNum(to time.Time) (int32, error) {
-	var num int64
-	err := GroupDB.Where("create_time <= ?", to).Count(&num).Error
-	return int32(num), err
+func (s *Statistics) GetTotalUserNumByDate(to time.Time) (num int64, err error) {
+	err = s.getUserModel().Where("create_time <= ?", to).Count(&num).Error
+	return num, err
+}
+
+func (s *Statistics) GetPrivateMessageNum(from, to time.Time) (num int64, err error) {
+	err = s.getChatLogModel().Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, constant.SingleChatType).Count(&num).Error
+	return num, err
+}
+
+func (s *Statistics) GetGroupMessageNum(from, to time.Time) (num int64, err error) {
+	err = s.getChatLogModel().Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.GroupChatType, constant.SuperGroupChatType}).Count(&num).Error
+	return num, err
+}
+
+func (s *Statistics) GetIncreaseGroupNum(from, to time.Time) (num int64, err error) {
+	err = s.getGroupModel().Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
+	return num, err
+}
+
+func (s *Statistics) GetTotalGroupNum() (num int64, err error) {
+	err = s.getGroupModel().Count(&num).Error
+	return num, err
+}
+
+func (s *Statistics) GetGroupNum(to time.Time) (num int64, err error) {
+	err = s.getGroupModel().Where("create_time <= ?", to).Count(&num).Error
+	return num, err
 }
 
 type activeGroup struct {
@@ -65,14 +77,14 @@ type activeGroup struct {
 	MessageNum int    `gorm:"column:message_num"`
 }
 
-func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) {
+func (s *Statistics) GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) {
 	var activeGroups []*activeGroup
-	err := ChatLogDB.Select("recv_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.GroupChatType, constant.SuperGroupChatType}).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error
+	err := s.getChatLogModel().Select("recv_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.GroupChatType, constant.SuperGroupChatType}).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error
 	for _, activeGroup := range activeGroups {
 		group := Group{
 			GroupID: activeGroup.Id,
 		}
-		GroupDB.Where("group_id= ? ", group.GroupID).Find(&group)
+		s.getGroupModel().Where("group_id= ? ", group.GroupID).Find(&group)
 		activeGroup.Name = group.GroupName
 	}
 	return activeGroups, err
@@ -84,16 +96,15 @@ type activeUser struct {
 	MessageNum int    `gorm:"column:message_num"`
 }
 
-func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) {
-	var activeUsers []*activeUser
-	err := ChatLogDB.Select("send_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, constant.SingleChatType).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error
+func (s *Statistics) GetActiveUsers(from, to time.Time, limit int) (activeUsers []*activeUser, err error) {
+	err = s.getChatLogModel().Select("send_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.SingleChatType, constant.GroupChatType, constant.SuperGroupChatType}).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error
 	for _, activeUser := range activeUsers {
 		user := User{
 			UserID: activeUser.ID,
 		}
-		err = UserDB.Select("user_id, name").Find(&user).Error
+		err = s.getUserModel().Select("user_id, name").Find(&user).Error
 		if err != nil {
-			continue
+			return nil, err
 		}
 		activeUser.Name = user.Nickname
 		activeUser.ID = user.UserID

pkg/common/db/relation/user_model.go

@@ -9,11 +9,6 @@ import (
 	"time"
 )
 
-var (
-	BlackListDB *gorm.DB
-	UserDB      *gorm.DB
-)
-
 func InitManager() {
 	for k, v := range config.Config.Manager.AppManagerUid {
 		_, err := GetUserByUserID(v)