v3 - main to cut out

pkg/common/db/mysql_model/im_mysql_model/demo_model.go

@@ -0,0 +1,41 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	_ "github.com/jinzhu/gorm"
+)
+
+func GetRegister(account string) (*db.Register, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var r db.Register
+	return &r, dbConn.Table("registers").Where("account = ?",
+		account).Take(&r).Error
+}
+
+func SetPassword(account, password, ex string) error {
+	r := db.Register{
+		Account:  account,
+		Password: password,
+		Ex:       ex,
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("registers").Create(&r).Error
+}
+
+func ResetPassword(account, password string) error {
+	r := db.Register{
+		Password: password,
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	dbConn.LogMode(false)
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("registers").Where("account = ?", account).Update(&r).Error
+}

pkg/common/db/mysql_model/im_mysql_model/friend_model.go

@@ -0,0 +1,91 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+	"time"
+)
+
+func InsertToFriend(toInsertFollow *db.Friend) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertFollow.CreateTime = time.Now()
+
+	err = dbConn.Table("friends").Create(toInsertFollow).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*db.Friend, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friend db.Friend
+	err = dbConn.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Take(&friend).Error
+	if err != nil {
+		return nil, err
+	}
+	return &friend, err
+}
+
+func GetFriendListByUserID(OwnerUserID string) ([]db.Friend, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friends []db.Friend
+	var x db.Friend
+	x.OwnerUserID = OwnerUserID
+	err = dbConn.Table("friends").Where("owner_user_id=?", OwnerUserID).Find(&friends).Error
+
+	if err != nil {
+		return nil, err
+	}
+	return friends, nil
+}
+
+func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friendIDList []string
+	err = dbConn.Table("friends").Select("friend_user_id").Where("owner_user_id=?", OwnerUserID).Find(&friendIDList).Error
+	if err != nil {
+		return nil, err
+	}
+	return friendIDList, nil
+}
+
+func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("update friends set remark=? where owner_user_id=? and friend_user_id=?", Remark, OwnerUserID, FriendUserID).Error
+	return err
+}
+
+func DeleteSingleFriendInfo(OwnerUserID, FriendUserID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(db.Friend{}).Error
+	return err
+}
+
+//type Friend struct {
+//	OwnerUserID    string    `gorm:"column:owner_user_id;primaryKey;"`
+//	FriendUserID   string    `gorm:"column:friend_user_id;primaryKey;"`
+//	Remark         string    `gorm:"column:remark"`
+//	CreateTime     time.Time `gorm:"column:create_time"`
+//	AddSource      int32     `gorm:"column:add_source"`
+//	OperatorUserID string    `gorm:"column:operator_user_id"`
+//	Ex             string    `gorm:"column:ex"`
+//}

pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go

@@ -0,0 +1,112 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"time"
+)
+
+//type FriendRequest struct {
+//	FromUserID    string    `gorm:"column:from_user_id;primaryKey;"`
+//	ToUserID      string    `gorm:"column:to_user_id;primaryKey;"`
+//	HandleResult  int32     `gorm:"column:handle_result"`
+//	ReqMessage    string    `gorm:"column:req_message"`
+//	CreateTime    time.Time `gorm:"column:create_time"`
+//	HandlerUserID string    `gorm:"column:handler_user_id"`
+//	HandleMsg     string    `gorm:"column:handle_msg"`
+//	HandleTime    time.Time `gorm:"column:handle_time"`
+//	Ex            string    `gorm:"column:ex"`
+//}
+
+// who apply to add me
+func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]db.FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var usersInfo []db.FriendRequest
+	err = dbConn.Table("friend_requests").Where("to_user_id=?", ToUserID).Find(&usersInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return usersInfo, nil
+}
+
+//I apply to add somebody
+func GetSendFriendApplicationListByUserID(FromUserID string) ([]db.FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var usersInfo []db.FriendRequest
+	err = dbConn.Table("friend_requests").Where("from_user_id=?", FromUserID).Find(&usersInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return usersInfo, nil
+}
+
+//FromUserId apply to add ToUserID
+func GetFriendApplicationByBothUserID(FromUserID, ToUserID string) (*db.FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friendRequest db.FriendRequest
+	err = dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?", FromUserID, ToUserID).Take(&friendRequest).Error
+	if err != nil {
+		return nil, err
+	}
+	return &friendRequest, nil
+}
+
+func UpdateFriendApplication(friendRequest *db.FriendRequest) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	friendRequest.CreateTime = time.Now()
+
+	return dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
+		friendRequest.FromUserID, friendRequest.ToUserID).Update(&friendRequest).Error
+}
+
+func InsertFriendApplication(friendRequest *db.FriendRequest, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+
+	if err = dbConn.Table("friend_requests").Create(friendRequest).Error; err == nil {
+		return nil
+	}
+
+	//t := dbConn.Debug().Table("friend_requests").Where("from_user_id = ? and to_user_id = ?", friendRequest.FromUserID, friendRequest.ToUserID).Select("*").Updates(*friendRequest)
+	//if t.RowsAffected == 0 {
+	//	return utils.Wrap(errors.New("RowsAffected == 0"), "no update")
+	//}
+	//return utils.Wrap(t.Error, "")
+
+	friendRequest.CreateTime = time.Now()
+	args["create_time"] = friendRequest.CreateTime
+	u := dbConn.Model(friendRequest).Updates(args)
+	//u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
+	// friendRequest.FromUserID, friendRequest.ToUserID).Update(&friendRequest)
+	//u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
+	//	friendRequest.FromUserID, friendRequest.ToUserID).Update(&friendRequest)
+	if u.RowsAffected != 0 {
+		return nil
+	}
+
+	if friendRequest.CreateTime.Unix() < 0 {
+		friendRequest.CreateTime = time.Now()
+	}
+	if friendRequest.HandleTime.Unix() < 0 {
+		friendRequest.HandleTime = utils.UnixSecondToTime(0)
+	}
+	err = dbConn.Table("friend_requests").Create(friendRequest).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

pkg/common/db/mysql_model/im_mysql_model/group_member_model.go

@@ -0,0 +1,316 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"errors"
+	"fmt"
+	"time"
+)
+
+//type GroupMember struct {
+//	GroupID            string    `gorm:"column:group_id;primaryKey;"`
+//	UserID             string    `gorm:"column:user_id;primaryKey;"`
+//	NickName           string    `gorm:"column:nickname"`
+//	FaceUrl            string    `gorm:"user_group_face_url"`
+//	RoleLevel int32     `gorm:"column:role_level"`
+//	JoinTime           time.Time `gorm:"column:join_time"`
+//	JoinSource int32 `gorm:"column:join_source"`
+//	OperatorUserID  string `gorm:"column:operator_user_id"`
+//	Ex string `gorm:"column:ex"`
+//}
+
+func InsertIntoGroupMember(toInsertInfo db.GroupMember) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertInfo.JoinTime = time.Now()
+	if toInsertInfo.RoleLevel == 0 {
+		toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
+	}
+	toInsertInfo.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
+	err = dbConn.Table("group_members").Create(toInsertInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetGroupMemberListByUserID(userID string) ([]db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []db.GroupMember
+	err = dbConn.Table("group_members").Where("user_id=?", userID).Find(&groupMemberList).Error
+	//err = dbConn.Table("group_members").Where("user_id=?", userID).Take(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func GetGroupMemberListByGroupID(groupID string) ([]db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []db.GroupMember
+	err = dbConn.Table("group_members").Where("group_id=?", groupID).Find(&groupMemberList).Error
+
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func GetGroupMemberIDListByGroupID(groupID string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	dbConn.LogMode(false)
+	var groupMembers []db.GroupMember
+	err = dbConn.Table("group_members").Select("user_id").Where("group_id=?", groupID).Find(&groupMembers).Error
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberIDList []string
+	for _, v := range groupMembers {
+		groupMemberIDList = append(groupMemberIDList, v.UserID)
+	}
+	return groupMemberIDList, nil
+}
+
+func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([]db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []db.GroupMember
+	err = dbConn.Table("group_members").Where("group_id=? and role_level=?", groupID, roleLevel).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func GetGroupMemberInfoByGroupIDAndUserID(groupID, userID string) (*db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMember db.GroupMember
+	err = dbConn.Table("group_members").Where("group_id=? and user_id=? ", groupID, userID).Limit(1).Take(&groupMember).Error
+	if err != nil {
+		return nil, err
+	}
+	return &groupMember, nil
+}
+
+func DeleteGroupMemberByGroupIDAndUserID(groupID, userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("group_members").Where("group_id=? and user_id=? ", groupID, userID).Delete(db.GroupMember{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func DeleteGroupMemberByGroupID(groupID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("group_members").Where("group_id=?  ", groupID).Delete(db.GroupMember{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func UpdateGroupMemberInfo(groupMemberInfo db.GroupMember) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("group_members").Where("group_id=? and user_id=?", groupMemberInfo.GroupID, groupMemberInfo.UserID).Update(&groupMemberInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetOwnerManagerByGroupID(groupID string) ([]db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []db.GroupMember
+	err = dbConn.Table("group_members").Where("group_id=? and role_level>?", groupID, constant.GroupOrdinaryUsers).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func GetGroupMemberNumByGroupID(groupID string) (uint32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, utils.Wrap(err, "DefaultGormDB failed")
+	}
+	var number uint32
+	err = dbConn.Table("group_members").Where("group_id=?", groupID).Count(&number).Error
+	if err != nil {
+		return 0, utils.Wrap(err, "")
+	}
+	return number, nil
+}
+
+func GetGroupOwnerInfoByGroupID(groupID string) (*db.GroupMember, error) {
+	omList, err := GetOwnerManagerByGroupID(groupID)
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range omList {
+		if v.RoleLevel == constant.GroupOwner {
+			return &v, nil
+		}
+	}
+
+	return nil, utils.Wrap(errors.New("no owner"), "")
+}
+
+func IsExistGroupMember(groupID, userID string) bool {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return false
+	}
+	var number int32
+	err = dbConn.Table("group_members").Where("group_id = ? and user_id = ?", groupID, userID).Count(&number).Error
+	if err != nil {
+		return false
+	}
+	if number != 1 {
+		return false
+	}
+	return true
+}
+
+func RemoveGroupMember(groupID string, UserID string) error {
+	return DeleteGroupMemberByGroupIDAndUserID(groupID, UserID)
+}
+
+func GetMemberInfoByID(groupID string, userID string) (*db.GroupMember, error) {
+	return GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
+}
+
+func GetGroupMemberByGroupID(groupID string, filter int32, begin int32, maxNumber int32) ([]db.GroupMember, error) {
+	var memberList []db.GroupMember
+	var err error
+	if filter >= 0 {
+		memberList, err = GetGroupMemberListByGroupIDAndRoleLevel(groupID, filter) //sorted by join time
+	} else {
+		memberList, err = GetGroupMemberListByGroupID(groupID)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	if begin >= int32(len(memberList)) {
+		return nil, nil
+	}
+
+	var end int32
+	if begin+int32(maxNumber) < int32(len(memberList)) {
+		end = begin + maxNumber
+	} else {
+		end = int32(len(memberList))
+	}
+	return memberList[begin:end], nil
+}
+
+func GetJoinedGroupIDListByUserID(userID string) ([]string, error) {
+	memberList, err := GetGroupMemberListByUserID(userID)
+	if err != nil {
+		return nil, err
+	}
+	var groupIDList []string = make([]string, len(memberList))
+	for _, v := range memberList {
+		groupIDList = append(groupIDList, v.GroupID)
+	}
+	return groupIDList, nil
+}
+
+func IsGroupOwnerAdmin(groupID, UserID string) bool {
+	groupMemberList, err := GetOwnerManagerByGroupID(groupID)
+	if err != nil {
+		return false
+	}
+	for _, v := range groupMemberList {
+		if v.UserID == UserID && v.RoleLevel > constant.GroupOrdinaryUsers {
+			return true
+		}
+	}
+	return false
+}
+
+func GetGroupMembersByGroupIdCMS(groupId string, userName string, showNumber, pageNumber int32) ([]db.GroupMember, error) {
+	var groupMembers []db.GroupMember
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return groupMembers, err
+	}
+	err = dbConn.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groupMembers).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMembers, nil
+}
+
+func GetGroupMembersCount(groupId, userName string) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var count int32
+	if err != nil {
+		return count, err
+	}
+	dbConn.LogMode(false)
+	if err := dbConn.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Count(&count).Error; err != nil {
+		return count, err
+	}
+	return count, nil
+}
+
+func UpdateGroupMemberInfoDefaultZero(groupMemberInfo db.GroupMember, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Model(groupMemberInfo).Updates(args).Error
+}
+
+//
+//func SelectGroupList(groupID string) ([]string, error) {
+//	var groupUserID string
+//	var groupList []string
+//	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+//	if err != nil {
+//		return groupList, err
+//	}
+//
+//	rows, err := dbConn.Model(&GroupMember{}).Where("group_id = ?", groupID).Select("user_id").Rows()
+//	if err != nil {
+//		return groupList, err
+//	}
+//	defer rows.Close()
+//	for rows.Next() {
+//		rows.Scan(&groupUserID)
+//		groupList = append(groupList, groupUserID)
+//	}
+//	return groupList, nil
+//}

pkg/common/db/mysql_model/im_mysql_model/group_model.go

@@ -0,0 +1,225 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"errors"
+	"fmt"
+	"github.com/jinzhu/gorm"
+	"time"
+)
+
+//type Group struct {
+//	GroupID       string    `gorm:"column:group_id;primaryKey;"`
+//	GroupName     string    `gorm:"column:name"`
+//	Introduction  string    `gorm:"column:introduction"`
+//	Notification  string    `gorm:"column:notification"`
+//	FaceUrl       string    `gorm:"column:face_url"`
+//	CreateTime    time.Time `gorm:"column:create_time"`
+//	Status        int32     `gorm:"column:status"`
+//	CreatorUserID string    `gorm:"column:creator_user_id"`
+//	GroupType     int32     `gorm:"column:group_type"`
+//	Ex            string    `gorm:"column:ex"`
+//}
+
+func InsertIntoGroup(groupInfo db.Group) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if groupInfo.GroupName == "" {
+		groupInfo.GroupName = "Group Chat"
+	}
+	groupInfo.CreateTime = time.Now()
+	err = dbConn.Table("groups").Create(groupInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetGroupInfoByGroupID(groupId string) (*db.Group, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, utils.Wrap(err, "")
+	}
+	var groupInfo db.Group
+	err = dbConn.Table("groups").Where("group_id=?", groupId).Take(&groupInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return &groupInfo, nil
+}
+
+func SetGroupInfo(groupInfo db.Group) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("groups").Where("group_id=?", groupInfo.GroupID).Update(&groupInfo).Error
+	return err
+}
+
+func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]db.Group, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var groups []db.Group
+	if err != nil {
+		return groups, err
+	}
+
+	err = dbConn.Table("groups").Where(fmt.Sprintf(" name like '%%%s%%' ", groupName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groups).Error
+	return groups, err
+}
+
+func GetGroups(pageNumber, showNumber int) ([]db.Group, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var groups []db.Group
+	if err != nil {
+		return groups, err
+	}
+
+	if err = dbConn.Table("groups").Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groups).Error; err != nil {
+		return groups, err
+	}
+	return groups, nil
+}
+
+func OperateGroupStatus(groupId string, groupStatus int32) error {
+	group := db.Group{
+		GroupID: groupId,
+		Status:  groupStatus,
+	}
+	if err := SetGroupInfo(group); err != nil {
+		return err
+	}
+	return nil
+}
+
+func DeleteGroup(groupId string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+
+	var group db.Group
+	var groupMembers []db.GroupMember
+	if err := dbConn.Table("groups").Where("group_id=?", groupId).Delete(&group).Error; err != nil {
+		return err
+	}
+	if err := dbConn.Table("group_members").Where("group_id=?", groupId).Delete(groupMembers).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func OperateGroupRole(userId, groupId string, roleLevel int32) (string, string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return "", "", err
+	}
+	groupMember := db.GroupMember{
+		UserID:  userId,
+		GroupID: groupId,
+	}
+	updateInfo := db.GroupMember{
+		RoleLevel: roleLevel,
+	}
+	groupMaster := db.GroupMember{}
+	switch roleLevel {
+	case constant.GroupOwner:
+		err = dbConn.Transaction(func(tx *gorm.DB) error {
+			result := dbConn.Table("group_members").Where("group_id = ? and role_level = ?", groupId, constant.GroupOwner).First(&groupMaster).Update(&db.GroupMember{
+				RoleLevel: constant.GroupOrdinaryUsers,
+			})
+			if result.Error != nil {
+				return result.Error
+			}
+			if result.RowsAffected == 0 {
+				return errors.New(fmt.Sprintf("user %s not exist in group %s or already operate", userId, groupId))
+			}
+
+			result = dbConn.Table("group_members").First(&groupMember).Update(updateInfo)
+			if result.Error != nil {
+				return result.Error
+			}
+			if result.RowsAffected == 0 {
+				return errors.New(fmt.Sprintf("user %s not exist in group %s or already operate", userId, groupId))
+			}
+			return nil
+		})
+
+	case constant.GroupOrdinaryUsers:
+		err = dbConn.Transaction(func(tx *gorm.DB) error {
+			result := dbConn.Table("group_members").Where("group_id = ? and role_level = ?", groupId, constant.GroupOwner).First(&groupMaster)
+			if result.Error != nil {
+				return result.Error
+			}
+			if result.RowsAffected == 0 {
+				return errors.New(fmt.Sprintf("user %s not exist in group %s or already operate", userId, groupId))
+			}
+			if groupMaster.UserID == userId {
+				return errors.New(fmt.Sprintf("user %s is master of %s, cant set to ordinary user", userId, groupId))
+			} else {
+				result = dbConn.Table("group_members").Find(&groupMember).Update(updateInfo)
+				if result.Error != nil {
+					return result.Error
+				}
+				if result.RowsAffected == 0 {
+					return errors.New(fmt.Sprintf("user %s not exist in group %s or already operate", userId, groupId))
+				}
+			}
+			return nil
+		})
+	}
+	return "", "", nil
+}
+
+func GetGroupsCountNum(group db.Group) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+
+	var count int32
+	if err := dbConn.Table("groups").Where(fmt.Sprintf(" name like '%%%s%%' ", group.GroupName)).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+func GetGroupById(groupId string) (db.Group, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	group := db.Group{
+		GroupID: groupId,
+	}
+	if err != nil {
+		return group, err
+	}
+
+	if err := dbConn.Table("groups").Find(&group).Error; err != nil {
+		return group, err
+	}
+	return group, nil
+}
+
+func GetGroupMaster(groupId string) (db.GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	groupMember := db.GroupMember{}
+	if err != nil {
+		return groupMember, err
+	}
+
+	if err := dbConn.Table("group_members").Where("role_level=? and group_id=?", constant.GroupOwner, groupId).Find(&groupMember).Error; err != nil {
+		return groupMember, err
+	}
+	return groupMember, nil
+}
+
+func UpdateGroupInfoDefaultZero(groupID string, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("groups").Where("group_id = ? ", groupID).Update(args).Error
+}

pkg/common/db/mysql_model/im_mysql_model/group_request_model.go

@@ -0,0 +1,209 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"time"
+)
+
+//type GroupRequest struct {
+//	UserID       string    `gorm:"column:user_id;primaryKey;"`
+//	GroupID      string    `gorm:"column:group_id;primaryKey;"`
+//	HandleResult int32    `gorm:"column:handle_result"`
+//	ReqMsg       string    `gorm:"column:req_msg"`
+//	HandledMsg   string    `gorm:"column:handled_msg"`
+//	ReqTime      time.Time `gorm:"column:req_time"`
+//	HandleUserID string    `gorm:"column:handle_user_id"`
+//	HandledTime  time.Time `gorm:"column:handle_time"`
+//	Ex           string    `gorm:"column:ex"`
+//}
+
+func UpdateGroupRequest(groupRequest db.GroupRequest) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if groupRequest.HandledTime.Unix() < 0 {
+		groupRequest.HandledTime = utils.UnixSecondToTime(0)
+	}
+	return dbConn.Table("group_requests").Where("group_id=? and user_id=?", groupRequest.GroupID, groupRequest.UserID).Update(&groupRequest).Error
+}
+
+func InsertIntoGroupRequest(toInsertInfo db.GroupRequest) error {
+	DelGroupRequestByGroupIDAndUserID(toInsertInfo.GroupID, toInsertInfo.UserID)
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+
+	if toInsertInfo.HandledTime.Unix() < 0 {
+		toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
+	}
+	u := dbConn.Table("group_requests").Where("group_id=? and user_id=?", toInsertInfo.GroupID, toInsertInfo.UserID).Update(&toInsertInfo)
+	if u.RowsAffected != 0 {
+		return nil
+	}
+
+	toInsertInfo.ReqTime = time.Now()
+	if toInsertInfo.HandledTime.Unix() < 0 {
+		toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
+	}
+
+	err = dbConn.Table("group_requests").Create(&toInsertInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*db.GroupRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupRequest db.GroupRequest
+	err = dbConn.Table("group_requests").Where("user_id=? and group_id=?", userID, groupID).Take(&groupRequest).Error
+	if err != nil {
+		return nil, err
+	}
+	return &groupRequest, nil
+}
+
+func DelGroupRequestByGroupIDAndUserID(groupID, userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("group_requests").Where("group_id=? and user_id=?", groupID, userID).Delete(db.GroupRequest{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetGroupRequestByGroupID(groupID string) ([]db.GroupRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupRequestList []db.GroupRequest
+	err = dbConn.Table("group_requests").Where("group_id=?", groupID).Find(&groupRequestList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupRequestList, nil
+}
+
+//received
+func GetGroupApplicationList(userID string) ([]db.GroupRequest, error) {
+	var groupRequestList []db.GroupRequest
+	memberList, err := GetGroupMemberListByUserID(userID)
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range memberList {
+		if v.RoleLevel > constant.GroupOrdinaryUsers {
+			list, err := GetGroupRequestByGroupID(v.GroupID)
+			if err != nil {
+				//		fmt.Println("111 GetGroupRequestByGroupID failed ", err.Error())
+				continue
+			}
+			//	fmt.Println("222 GetGroupRequestByGroupID ok ", list)
+			groupRequestList = append(groupRequestList, list...)
+			//	fmt.Println("333 GetGroupRequestByGroupID ok ", groupRequestList)
+		}
+	}
+	return groupRequestList, nil
+}
+
+func GetUserReqGroupByUserID(userID string) ([]db.GroupRequest, error) {
+	var groupRequestList []db.GroupRequest
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error
+	return groupRequestList, err
+}
+
+//
+//func GroupApplicationResponse(pb *group.GroupApplicationResponseReq) (*group.CommonResp, error) {
+//
+//	ownerUser, err := FindGroupMemberInfoByGroupIdAndUserId(pb.GroupID, pb.OwnerID)
+//	if err != nil {
+//		log.ErrorByKv("FindGroupMemberInfoByGroupIdAndUserId failed", pb.OperationID, "groupId", pb.GroupID, "ownerID", pb.OwnerID)
+//		return nil, err
+//	}
+//	if ownerUser.AdministratorLevel <= 0 {
+//		return nil, errors.New("insufficient permissions")
+//	}
+//
+//	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+//	if err != nil {
+//		return nil, err
+//	}
+//	var groupRequest GroupRequest
+//	err = dbConn.Raw("select * from `group_request` where handled_user = ? and group_id = ? and from_user_id = ? and to_user_id = ?",
+//		"", pb.GroupID, pb.FromUserID, pb.ToUserID).Scan(&groupRequest).Error
+//	if err != nil {
+//		log.ErrorByKv("find group_request info failed", pb.OperationID, "groupId", pb.GroupID, "fromUserId", pb.FromUserID, "toUserId", pb.OwnerID)
+//		return nil, err
+//	}
+//
+//	if groupRequest.Flag != 0 {
+//		return nil, errors.New("application has already handle")
+//	}
+//
+//	var saveFlag int
+//	if pb.HandleResult == 0 {
+//		saveFlag = -1
+//	} else if pb.HandleResult == 1 {
+//		saveFlag = 1
+//	} else {
+//		return nil, errors.New("parma HandleResult error")
+//	}
+//	err = dbConn.Exec("update `group_request` set flag = ?, handled_msg = ?, handled_user = ? where group_id = ? and from_user_id = ? and to_user_id = ?",
+//		saveFlag, pb.HandledMsg, pb.OwnerID, groupRequest.GroupID, groupRequest.FromUserID, groupRequest.ToUserID).Error
+//	if err != nil {
+//		log.ErrorByKv("update group request failed", pb.OperationID, "groupID", pb.GroupID, "flag", saveFlag, "ownerId", pb.OwnerID, "fromUserId", pb.FromUserID, "toUserID", pb.ToUserID)
+//		return nil, err
+//	}
+//
+//	if saveFlag == 1 {
+//		if groupRequest.ToUserID == "0" {
+//			err = InsertIntoGroupMember(pb.GroupID, pb.FromUserID, groupRequest.FromUserNickname, groupRequest.FromUserFaceUrl, 0)
+//			if err != nil {
+//				log.ErrorByKv("InsertIntoGroupMember failed", pb.OperationID, "groupID", pb.GroupID, "fromUserId", pb.FromUserID)
+//				return nil, err
+//			}
+//		} else {
+//			err = InsertIntoGroupMember(pb.GroupID, pb.ToUserID, groupRequest.ToUserNickname, groupRequest.ToUserFaceUrl, 0)
+//			if err != nil {
+//				log.ErrorByKv("InsertIntoGroupMember failed", pb.OperationID, "groupID", pb.GroupID, "fromUserId", pb.FromUserID)
+//				return nil, err
+//			}
+//		}
+//	}
+//
+//	return &group.GroupApplicationResponseResp{}, nil
+//}
+
+//func FindGroupBeInvitedRequestInfoByUidAndGroupID(groupId, uid string) (*GroupRequest, error) {
+//	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+//	if err != nil {
+//		return nil, err
+//	}
+//	var beInvitedRequestUserInfo GroupRequest
+//	err = dbConn.Table("group_request").Where("to_user_id=? and group_id=?", uid, groupId).Find(&beInvitedRequestUserInfo).Error
+//	if err != nil {
+//		return nil, err
+//	}
+//	return &beInvitedRequestUserInfo, nil
+//
+//}
+
+//func InsertGroupRequest(groupId, fromUser, fromUserNickName, fromUserFaceUrl, toUser, requestMsg, handledMsg string, handleStatus int) error {
+//	return nil
+//}

pkg/common/db/mysql_model/im_mysql_model/message_cms.go

@@ -0,0 +1,68 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"fmt"
+)
+
+func GetChatLog(chatLog db.ChatLog, pageNumber, showNumber int32) ([]db.ChatLog, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var chatLogs []db.ChatLog
+	if err != nil {
+		return chatLogs, err
+	}
+	dbConn.LogMode(false)
+	db := dbConn.Table("chat_logs").
+		Where(fmt.Sprintf(" content like '%%%s%%'", chatLog.Content)).
+		Limit(showNumber).Offset(showNumber * (pageNumber - 1))
+	if chatLog.SessionType != 0 {
+		db = db.Where("session_type = ?", chatLog.SessionType)
+	}
+	if chatLog.ContentType != 0 {
+		db = db.Where("content_type = ?", chatLog.ContentType)
+	}
+	if chatLog.SendID != "" {
+		db = db.Where("send_id = ?", chatLog.SendID)
+	}
+	if chatLog.RecvID != "" {
+		db = db.Where("recv_id = ?", chatLog.RecvID)
+	}
+	if chatLog.SendTime.Unix() > 0 {
+		db = db.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
+	}
+	err = db.Find(&chatLogs).Error
+	return chatLogs, err
+}
+
+func GetChatLogCount(chatLog db.ChatLog) (int64, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var chatLogs []db.ChatLog
+	var count int64
+	if err != nil {
+		return count, err
+	}
+	dbConn.LogMode(false)
+	db := dbConn.Table("chat_logs").
+		Where(fmt.Sprintf(" content like '%%%s%%'", chatLog.Content))
+	if chatLog.SessionType != 0 {
+		db = db.Where("session_type = ?", chatLog.SessionType)
+	}
+	if chatLog.ContentType != 0 {
+		db = db.Where("content_type = ?", chatLog.ContentType)
+	}
+	if chatLog.SendID != "" {
+		db = db.Where("send_id = ?", chatLog.SendID)
+	}
+	if chatLog.RecvID != "" {
+		db = db.Where("recv_id = ?", chatLog.RecvID)
+	}
+	if chatLog.SendTime.Unix() > 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
+		db = db.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
+	}
+
+	err = db.Find(&chatLogs).Count(&count).Error
+	return count, err
+}

pkg/common/db/mysql_model/im_mysql_model/organization_model.go

@@ -0,0 +1,182 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func CreateDepartment(department *db.Department) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	department.CreateTime = time.Now()
+	return dbConn.Table("departments").Create(department).Error
+}
+
+func GetDepartment(departmentID string) (error, *db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var department db.Department
+	err = dbConn.Table("departments").Where("department_id=?", departmentID).Find(&department).Error
+	return err, &department
+}
+
+func UpdateDepartment(department *db.Department, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(department).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(args).Error
+	}
+	return nil
+}
+
+func GetSubDepartmentList(departmentID string) (error, []db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentList []db.Department
+	err = dbConn.Table("departments").Where("parent_id=?", departmentID).Find(&departmentList).Error
+	return err, departmentList
+}
+
+func DeleteDepartment(departmentID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", departmentID).Delete(db.Department{}).Error; err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=?", departmentID).Delete(db.DepartmentMember{}).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func CreateOrganizationUser(organizationUser *db.OrganizationUser) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	organizationUser.CreateTime = time.Now()
+
+	return dbConn.Table("organization_users").Create(organizationUser).Error
+}
+
+func GetOrganizationUser(userID string) (error, *db.OrganizationUser) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	err = dbConn.Table("organization_users").Where("user_id=?", userID).Take(&organizationUser).Error
+	return err, &organizationUser
+}
+
+func UpdateOrganizationUser(organizationUser *db.OrganizationUser, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(organizationUser).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(args).Error
+	}
+	return nil
+}
+
+func CreateDepartmentMember(departmentMember *db.DepartmentMember) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	departmentMember.CreateTime = time.Now()
+	return dbConn.Table("department_members").Create(departmentMember).Error
+}
+
+func GetUserInDepartment(userID string) (error, []db.DepartmentMember) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("user_id=?", userID).Take(&departmentMemberList).Error
+	return err, departmentMemberList
+}
+
+func UpdateUserInDepartment(departmentMember *db.DepartmentMember, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=? ADN user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+		Updates(departmentMember).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("department_members").Where("department_id=? ADN user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+			Updates(args).Error
+	}
+	return nil
+}
+
+func DeleteUserInDepartment(departmentID, userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("department_id=? ADN user_id=?", departmentID, userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteUserInAllDepartment(userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("user_id=?", userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteOrganizationUser(OrganizationUserID string) error {
+	if err := DeleteUserInAllDepartment(OrganizationUserID); err != nil {
+		return err
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("organization_users").Where("user_id=?", OrganizationUserID).Delete(db.OrganizationUser{}).Error
+}
+
+func GetDepartmentMemberUserIDList(departmentID string) (error, []string) {
+	//dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	//if err != nil {
+	//	return err
+	//}
+	//return dbConn.Table("department_members").Where("user_id=?", userID).Delete(db.DepartmentMember{}).Error
+
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("department_id=?", departmentID).Take(&departmentMemberList).Error
+	if err != nil {
+		return err, nil
+	}
+	var userIDList []string = make([]string, 0)
+	for _, v := range departmentMemberList {
+		userIDList = append(userIDList, v.UserID)
+	}
+	return err, userIDList
+}

pkg/common/db/mysql_model/im_mysql_model/statistics_model.go

@@ -0,0 +1,153 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func GetActiveUserNum(from, to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("chat_logs").Select("count(distinct(send_id))").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
+	return num, err
+}
+
+func GetIncreaseUserNum(from, to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("users").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
+	return num, err
+}
+
+func GetTotalUserNum() (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("users").Count(&num).Error
+	return num, err
+}
+
+func GetTotalUserNumByDate(to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("users").Where("create_time <= ?", to).Count(&num).Error
+	return num, err
+}
+
+func GetPrivateMessageNum(from, to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Count(&num).Error
+	return num, err
+}
+
+func GetGroupMessageNum(from, to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Count(&num).Error
+	return num, err
+}
+
+func GetIncreaseGroupNum(from, to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("groups").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
+	return num, err
+}
+
+func GetTotalGroupNum() (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("groups").Count(&num).Error
+	return num, err
+}
+
+func GetGroupNum(to time.Time) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var num int32
+	err = dbConn.Table("groups").Where("create_time <= ?", to).Count(&num).Error
+	return num, err
+}
+
+type activeGroup struct {
+	Name       string
+	Id         string `gorm:"column:recv_id"`
+	MessageNum int    `gorm:"column:message_num"`
+}
+
+func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var activeGroups []*activeGroup
+	if err != nil {
+		return activeGroups, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("chat_logs").Select("recv_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error
+	for _, activeGroup := range activeGroups {
+		group := db.Group{
+			GroupID: activeGroup.Id,
+		}
+		dbConn.Table("groups").Where("group_id= ? ", group.GroupID).Find(&group)
+		activeGroup.Name = group.GroupName
+	}
+	return activeGroups, err
+}
+
+type activeUser struct {
+	Name       string
+	Id         string `gorm:"column:send_id"`
+	MessageNum int    `gorm:"column:message_num"`
+}
+
+func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var activeUsers []*activeUser
+	if err != nil {
+		return activeUsers, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("chat_logs").Select("send_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error
+	for _, activeUser := range activeUsers {
+		user := db.User{
+			UserID: activeUser.Id,
+		}
+		dbConn.Table("users").Select("user_id, name").Find(&user)
+		activeUser.Name = user.Nickname
+	}
+	return activeUsers, err
+}

pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go

@@ -0,0 +1,58 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/utils"
+	"time"
+)
+
+func InsertInToUserBlackList(black db.Black) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	black.CreateTime = time.Now()
+	err = dbConn.Table("blacks").Create(black).Error
+	return err
+}
+
+//type Black struct {
+//	OwnerUserID    string    `gorm:"column:owner_user_id;primaryKey;"`
+//	BlockUserID    string    `gorm:"column:block_user_id;primaryKey;"`
+//	CreateTime     time.Time `gorm:"column:create_time"`
+//	AddSource      int32     `gorm:"column:add_source"`
+//	OperatorUserID int32     `gorm:"column:operator_user_id"`
+//	Ex             string    `gorm:"column:ex"`
+//}
+
+func CheckBlack(ownerUserID, blockUserID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	var black db.Black
+	err = dbConn.Table("blacks").Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Find(&black).Error
+	return err
+}
+
+func RemoveBlackList(ownerUserID, blockUserID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("blacks").Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Delete(db.Black{}).Error
+	return utils.Wrap(err, "RemoveBlackList failed")
+}
+
+func GetBlackListByUserID(ownerUserID string) ([]db.Black, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var blackListUsersInfo []db.Black
+	err = dbConn.Table("blacks").Where("owner_user_id=?", ownerUserID).Find(&blackListUsersInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return blackListUsersInfo, nil
+}

pkg/common/db/mysql_model/im_mysql_model/user_model.go

@@ -0,0 +1,398 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/utils"
+	"fmt"
+	"time"
+
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+)
+
+func init() {
+	//init managers
+	for k, v := range config.Config.Manager.AppManagerUid {
+		user, err := GetUserByUserID(v)
+		if err != nil {
+			fmt.Println("GetUserByUserID failed ", err.Error(), v, user)
+		} else {
+			continue
+		}
+		var appMgr db.User
+		appMgr.UserID = v
+		appMgr.Nickname = "AppManager" + utils.IntToString(k+1)
+		appMgr.AppMangerLevel = constant.AppAdmin
+		err = UserRegister(appMgr)
+		if err != nil {
+			fmt.Println("AppManager insert error", err.Error(), appMgr, "time: ", appMgr.Birth.Unix())
+		}
+
+	}
+}
+
+func UserRegister(user db.User) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	user.CreateTime = time.Now()
+	if user.AppMangerLevel == 0 {
+		user.AppMangerLevel = constant.AppOrdinaryUsers
+	}
+	if user.Birth.Unix() < 0 {
+		user.Birth = utils.UnixSecondToTime(0)
+	}
+	err = dbConn.Table("users").Create(&user).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func DeleteUser(userID string) (i int64) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0
+	}
+	i = dbConn.Table("users").Where("user_id=?", userID).Delete(db.User{}).RowsAffected
+	return i
+}
+
+func GetUserByUserID(userID string) (*db.User, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var user db.User
+	err = dbConn.Table("users").Where("user_id=?", userID).Take(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func GetUserNameByUserID(userID string) (string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return "", err
+	}
+	var user db.User
+	err = dbConn.Table("users").Select("name").Where("user_id=?", userID).First(&user).Error
+	if err != nil {
+		return "", err
+	}
+	return user.Nickname, nil
+}
+
+func UpdateUserInfo(user db.User) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("users").Where("user_id=?", user.UserID).Update(&user).Error
+	return err
+}
+
+func SelectAllUserID() ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var resultArr []string
+	err = dbConn.Table("users").Pluck("user_id", &resultArr).Error
+	if err != nil {
+		return nil, err
+	}
+	return resultArr, nil
+}
+
+func SelectSomeUserID(userIDList []string) ([]string, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	dbConn.LogMode(false)
+	if err != nil {
+		return nil, err
+	}
+	var resultArr []string
+	err = dbConn.Table("users").Where("user_id IN (?) ", userIDList).Pluck("user_id", &resultArr).Error
+
+	if err != nil {
+		return nil, err
+	}
+	return resultArr, nil
+}
+
+func GetUsers(showNumber, pageNumber int32) ([]db.User, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var users []db.User
+	if err != nil {
+		return users, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("users").Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error
+	if err != nil {
+		return users, err
+	}
+	return users, err
+}
+
+func AddUser(userId, phoneNumber, name string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	user := db.User{
+		PhoneNumber: phoneNumber,
+		Birth:       time.Now(),
+		CreateTime:  time.Now(),
+		UserID:      userId,
+		Nickname:    name,
+	}
+	result := dbConn.Table("users").Create(&user)
+	return result.Error
+}
+
+func UserIsBlock(userId string) (bool, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return false, err
+	}
+	var user db.BlackList
+	rows := dbConn.Table("black_lists").Where("uid=?", userId).First(&user).RowsAffected
+	if rows >= 1 {
+		return true, nil
+	}
+	return false, nil
+}
+
+func BlockUser(userId, endDisableTime string) error {
+	user, err := GetUserByUserID(userId)
+	if err != nil || user.UserID == "" {
+		return err
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	end, err := time.Parse("2006-01-02 15:04:05", endDisableTime)
+	if err != nil {
+		return err
+	}
+	if end.Before(time.Now()) {
+		return constant.ErrDB
+	}
+	var blockUser db.BlackList
+	dbConn.Table("black_lists").Where("uid=?", userId).First(&blockUser)
+	if blockUser.UserId != "" {
+		dbConn.Model(&blockUser).Where("uid=?", blockUser.UserId).Update("end_disable_time", end)
+		return nil
+	}
+	blockUser = db.BlackList{
+		UserId:           userId,
+		BeginDisableTime: time.Now(),
+		EndDisableTime:   end,
+	}
+	result := dbConn.Create(&blockUser)
+	return result.Error
+}
+
+func UnBlockUser(userId string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	result := dbConn.Where("uid=?", userId).Delete(&db.BlackList{})
+	return result.Error
+}
+
+type BlockUserInfo struct {
+	User             db.User
+	BeginDisableTime time.Time
+	EndDisableTime   time.Time
+}
+
+func GetBlockUserById(userId string) (BlockUserInfo, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var blockUserInfo BlockUserInfo
+	blockUser := db.BlackList{
+		UserId: userId,
+	}
+	if err != nil {
+		return blockUserInfo, err
+	}
+	if err = dbConn.Table("black_lists").Where("uid=?", userId).Find(&blockUser).Error; err != nil {
+		return blockUserInfo, err
+	}
+	user := db.User{
+		UserID: blockUser.UserId,
+	}
+	if err := dbConn.Find(&user).Error; err != nil {
+		return blockUserInfo, err
+	}
+	blockUserInfo.User.UserID = user.UserID
+	blockUserInfo.User.FaceURL = user.UserID
+	blockUserInfo.User.Nickname = user.Nickname
+	blockUserInfo.BeginDisableTime = blockUser.BeginDisableTime
+	blockUserInfo.EndDisableTime = blockUser.EndDisableTime
+	return blockUserInfo, nil
+}
+
+func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var blockUserInfos []BlockUserInfo
+	var blockUsers []db.BlackList
+	if err != nil {
+		return blockUserInfos, err
+	}
+	dbConn.LogMode(false)
+	if err = dbConn.Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&blockUsers).Error; err != nil {
+		return blockUserInfos, err
+	}
+	for _, blockUser := range blockUsers {
+		var user db.User
+		if err := dbConn.Table("users").Where("user_id=?", blockUser.UserId).First(&user).Error; err == nil {
+			blockUserInfos = append(blockUserInfos, BlockUserInfo{
+				User: db.User{
+					UserID:   user.UserID,
+					Nickname: user.Nickname,
+					FaceURL:  user.FaceURL,
+				},
+				BeginDisableTime: blockUser.BeginDisableTime,
+				EndDisableTime:   blockUser.EndDisableTime,
+			})
+		}
+	}
+	return blockUserInfos, nil
+}
+
+func GetUserByName(userName string, showNumber, pageNumber int32) ([]db.User, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	var users []db.User
+	if err != nil {
+		return users, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", userName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error
+	return users, err
+}
+
+func GetUsersCount(user db.User) (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var count int32
+	if err := dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", user.Nickname)).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+func GetBlockUsersNumCount() (int32, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0, err
+	}
+	dbConn.LogMode(false)
+	var count int32
+	if err := dbConn.Model(&db.BlackList{}).Count(&count).Error; err != nil {
+		return 0, err
+	}
+	return count, nil
+}
+
+func SetConversation(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	} else {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+		//force update
+		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt, "is_pinned": conversation.IsPinned, "is_private_chat": conversation.IsPrivateChat}).Error
+	}
+}
+
+func PeerUserSetConversation(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	}
+	log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+	//force update
+	return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+		Update(map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}).Error
+
+}
+
+func SetRecvMsgOpt(conversation db.Conversation) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	dbConn.LogMode(false)
+	newConversation := conversation
+	if dbConn.Model(&db.Conversation{}).Find(&newConversation).RowsAffected == 0 {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create")
+		return dbConn.Model(&db.Conversation{}).Create(conversation).Error
+		// if exist, then update record
+	} else {
+		log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
+		//force update
+		return dbConn.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
+			Update(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt}).Error
+	}
+}
+
+func GetUserAllConversations(ownerUserID string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	dbConn.LogMode(false)
+	err = dbConn.Model(&db.Conversation{}).Where("owner_user_id=?", ownerUserID).Find(&conversations).Error
+	return conversations, err
+}
+
+func GetConversation(OwnerUserID, conversationID string) (db.Conversation, error) {
+	var conversation db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversation, err
+	}
+	err = dbConn.Model(&db.Conversation{
+		OwnerUserID:    OwnerUserID,
+		ConversationID: conversationID,
+	}).Find(&conversation).Error
+	return conversation, err
+}
+
+func GetConversations(OwnerUserID string, conversationIDs []string) ([]db.Conversation, error) {
+	var conversations []db.Conversation
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return conversations, err
+	}
+	err = dbConn.Model(&db.Conversation{}).Where("conversation_id IN (?) and  owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error
+	return conversations, err
+}

pkg/common/db/mysql_model/im_mysql_msg_model/chat_log_model.go

@@ -0,0 +1,51 @@
+/*
+** description("").
+** copyright('tuoyun,www.tuoyun.net').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/3/4 11:18).
+ */
+package im_mysql_msg_model
+
+import (
+	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/proto"
+	"github.com/jinzhu/copier"
+)
+
+func InsertMessageToChatLog(msg pbMsg.MsgDataToMQ) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	chatLog := new(db.ChatLog)
+	copier.Copy(chatLog, msg.MsgData)
+	switch msg.MsgData.SessionType {
+	case constant.GroupChatType:
+		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 server_api_params.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)
+	log.NewDebug("test", "this is ", chatLog)
+	return dbConn.Table("chat_logs").Create(chatLog).Error
+}

pkg/common/db/mysql_model/im_mysql_msg_model/hash_code.go

@@ -0,0 +1,36 @@
+package im_mysql_msg_model
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/db"
+	"hash/crc32"
+	"strconv"
+)
+
+func getHashMsgDBAddr(userID string) string {
+	hCode := crc32.ChecksumIEEE([]byte(userID))
+	return config.Config.Mysql.DBAddress[hCode%uint32(len(config.Config.Mysql.DBAddress))]
+}
+
+func getHashMsgTableIndex(userID string) int {
+	hCode := crc32.ChecksumIEEE([]byte(userID))
+	return int(hCode % uint32(config.Config.Mysql.DBMsgTableNum))
+}
+
+func QueryUserMsgID(userID string) ([]string, error) {
+	dbAddress, dbTableIndex := getHashMsgDBAddr(userID), getHashMsgTableIndex(userID)
+	dbTableName := "receive" + strconv.Itoa(dbTableIndex)
+
+	dbConn, _ := db.DB.MysqlDB.GormDB(dbAddress, config.Config.Mysql.DBTableName)
+
+	var msgID string
+	var msgIDList []string
+	rows, _ := dbConn.Raw("select msg_id from ? where user_id = ?", dbTableName, userID).Rows()
+	defer rows.Close()
+	for rows.Next() {
+		rows.Scan(&msgID)
+		msgIDList = append(msgIDList, msgID)
+	}
+
+	return msgIDList, nil
+}