mv src/common src/utils src/grpc-etcdv3 to pkg

pkg/common/db/model.go

@@ -0,0 +1,60 @@
+package db
+
+import (
+	"Open_IM/pkg/common/config"
+	"github.com/garyburd/redigo/redis"
+	"gopkg.in/mgo.v2"
+	"time"
+)
+
+var DB DataBases
+
+type DataBases struct {
+	MysqlDB    mysqlDB
+	mgoSession *mgo.Session
+	redisPool  *redis.Pool
+}
+
+func key(dbAddress, dbName string) string {
+	return dbAddress + "_" + dbName
+}
+
+func init() {
+	//mysql init
+	initMysqlDB()
+	// mongo init
+	mgoDailInfo := &mgo.DialInfo{
+		Addrs:     config.Config.Mongo.DBAddress,
+		Direct:    config.Config.Mongo.DBDirect,
+		Timeout:   time.Second * time.Duration(config.Config.Mongo.DBTimeout),
+		Database:  config.Config.Mongo.DBDatabase,
+		Source:    config.Config.Mongo.DBSource,
+		Username:  config.Config.Mongo.DBUserName,
+		Password:  config.Config.Mongo.DBPassword,
+		PoolLimit: config.Config.Mongo.DBMaxPoolSize,
+	}
+	mgoSession, err := mgo.DialWithInfo(mgoDailInfo)
+	if err != nil {
+		panic(err)
+	}
+	DB.mgoSession = mgoSession
+	DB.mgoSession.SetMode(mgo.Monotonic, true)
+
+	// redis pool init
+	DB.redisPool = &redis.Pool{
+		MaxIdle:     config.Config.Redis.DBMaxIdle,
+		MaxActive:   config.Config.Redis.DBMaxActive,
+		IdleTimeout: time.Duration(config.Config.Redis.DBIdleTimeout) * time.Second,
+		Dial: func() (redis.Conn, error) {
+			return redis.Dial(
+				"tcp",
+				config.Config.Redis.DBAddress,
+				redis.DialReadTimeout(time.Duration(1000)*time.Millisecond),
+				redis.DialWriteTimeout(time.Duration(1000)*time.Millisecond),
+				redis.DialConnectTimeout(time.Duration(1000)*time.Millisecond),
+				redis.DialDatabase(0),
+				redis.DialPassword(config.Config.Redis.DBPassWord),
+			)
+		},
+	}
+}

pkg/common/db/mongoModel.go

@@ -0,0 +1,233 @@
+package db
+
+import (
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
+	"errors"
+	"github.com/golang/protobuf/proto"
+	"gopkg.in/mgo.v2/bson"
+	"time"
+)
+
+const cChat = "chat"
+const cGroup = "group"
+
+type MsgInfo struct {
+	SendTime int64
+	Msg      []byte
+}
+
+type UserChat struct {
+	UID string
+	Msg []MsgInfo
+}
+
+type GroupMember struct {
+	GroupID string
+	UIDList []string
+}
+
+func (d *DataBases) GetUserChat(uid string, seqBegin, seqEnd int64) (SingleMsg []*pbMsg.MsgFormat, GroupMsg []*pbMsg.MsgFormat, MaxSeq int64, MinSeq int64, err error) {
+	count := 0
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return nil, nil, MaxSeq, MinSeq, errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
+
+	sChat := UserChat{}
+	if err = c.Find(bson.M{"uid": uid}).One(&sChat); err != nil {
+		return nil, nil, MaxSeq, MinSeq, err
+	}
+	pChat := pbMsg.MsgSvrToPushSvrChatMsg{}
+	for i := 0; i < len(sChat.Msg); i++ {
+		temp := new(pbMsg.MsgFormat)
+		if err = proto.Unmarshal(sChat.Msg[i].Msg, &pChat); err != nil {
+			return nil, nil, MaxSeq, MinSeq, err
+		}
+		if pChat.RecvSeq >= seqBegin && pChat.RecvSeq <= seqEnd {
+			temp.SendID = pChat.SendID
+			temp.RecvID = pChat.RecvID
+			temp.MsgFrom = pChat.MsgFrom
+			temp.Seq = pChat.RecvSeq
+			temp.ServerMsgID = pChat.MsgID
+			temp.SendTime = pChat.SendTime
+			temp.Content = pChat.Content
+			temp.ContentType = pChat.ContentType
+			temp.SenderPlatformID = pChat.PlatformID
+			temp.ClientMsgID = pChat.ClientMsgID
+			temp.SenderFaceURL = pChat.SenderFaceURL
+			temp.SenderNickName = pChat.SenderNickName
+			if pChat.RecvSeq > MaxSeq {
+				MaxSeq = pChat.RecvSeq
+			}
+			if count == 0 {
+				MinSeq = pChat.RecvSeq
+			}
+			if pChat.RecvSeq < MinSeq {
+				MinSeq = pChat.RecvSeq
+			}
+			if pChat.SessionType == constant.SingleChatType {
+				SingleMsg = append(SingleMsg, temp)
+			} else {
+				GroupMsg = append(GroupMsg, temp)
+			}
+			count++
+		}
+	}
+
+	return SingleMsg, GroupMsg, MaxSeq, MinSeq, nil
+}
+
+func (d *DataBases) SaveUserChat(uid string, sendTime int64, m proto.Message) error {
+
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
+
+	n, err := c.Find(bson.M{"uid": uid}).Count()
+	if err != nil {
+		return err
+	}
+
+	sMsg := MsgInfo{}
+	sMsg.SendTime = sendTime
+	if sMsg.Msg, err = proto.Marshal(m); err != nil {
+		return err
+	}
+
+	if n == 0 {
+		sChat := UserChat{}
+		sChat.UID = uid
+		sChat.Msg = append(sChat.Msg, sMsg)
+		err = c.Insert(&sChat)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = c.Update(bson.M{"uid": uid}, bson.M{"$push": bson.M{"msg": sMsg}})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (d *DataBases) DelUserChat(uid string) error {
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
+
+	delTime := time.Now().Unix() - int64(config.Config.Mongo.DBRetainChatRecords)*24*3600
+	if err := c.Update(bson.M{"uid": uid}, bson.M{"$pull": bson.M{"msg": bson.M{"sendtime": bson.M{"$lte": delTime}}}}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *DataBases) MgoUserCount() (int, error) {
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return 0, errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
+
+	return c.Find(nil).Count()
+}
+
+func (d *DataBases) MgoSkipUID(count int) (string, error) {
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return "", errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
+
+	sChat := UserChat{}
+	c.Find(nil).Skip(count).Limit(1).One(&sChat)
+	return sChat.UID, nil
+}
+
+func (d *DataBases) GetGroupMember(groupID string) []string {
+	groupInfo := GroupMember{}
+	groupInfo.GroupID = groupID
+	groupInfo.UIDList = make([]string, 0)
+
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return groupInfo.UIDList
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cGroup)
+
+	if err := c.Find(bson.M{"groupid": groupInfo.GroupID}).One(&groupInfo); err != nil {
+		return groupInfo.UIDList
+	}
+
+	return groupInfo.UIDList
+}
+
+func (d *DataBases) AddGroupMember(groupID, uid string) error {
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cGroup)
+
+	n, err := c.Find(bson.M{"groupid": groupID}).Count()
+	if err != nil {
+		return err
+	}
+
+	if n == 0 {
+		groupInfo := GroupMember{}
+		groupInfo.GroupID = groupID
+		groupInfo.UIDList = append(groupInfo.UIDList, uid)
+		err = c.Insert(&groupInfo)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = c.Update(bson.M{"groupid": groupID}, bson.M{"$addToSet": bson.M{"uidlist": uid}})
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (d *DataBases) DelGroupMember(groupID, uid string) error {
+	session := d.mgoSession.Clone()
+	if session == nil {
+		return errors.New("session == nil")
+	}
+	defer session.Close()
+
+	c := session.DB(config.Config.Mongo.DBDatabase).C(cGroup)
+
+	if err := c.Update(bson.M{"groupid": groupID}, bson.M{"$pull": bson.M{"uidlist": uid}}); err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/common/db/mysql.go

@@ -0,0 +1,136 @@
+package db
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"fmt"
+	"github.com/jinzhu/gorm"
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+	"sync"
+	"time"
+)
+
+type mysqlDB struct {
+	sync.RWMutex
+	dbMap map[string]*gorm.DB
+}
+
+func initMysqlDB() {
+	//When there is no open IM database, connect to the mysql built-in database to create openIM database
+	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
+		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], "mysql")
+
+	db, err := gorm.Open("mysql", dsn)
+	if err != nil {
+		log.Error("", "", dsn)
+		panic(err)
+	}
+
+	//Check the database and table during initialization
+	sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s ;", config.Config.Mysql.DBDatabaseName)
+	err = db.Exec(sql).Error
+	if err != nil {
+		panic(err)
+	}
+	db.Close()
+
+	dsn = fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
+		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, config.Config.Mysql.DBAddress[0], config.Config.Mysql.DBDatabaseName)
+	db, err = gorm.Open("mysql", dsn)
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable := "CREATE TABLE IF NOT EXISTS `user` (\n  `uid` varchar(64) NOT NULL,\n  `name` varchar(64) DEFAULT NULL,\n  `icon` varchar(1024) DEFAULT NULL,\n  `gender` int(11) unsigned zerofill DEFAULT NULL,\n  `mobile` varchar(32) DEFAULT NULL,\n  `birth` varchar(16) DEFAULT NULL,\n  `email` varchar(64) DEFAULT NULL,\n  `ex` varchar(1024) DEFAULT NULL,\n  `create_time` datetime DEFAULT NULL,\n  PRIMARY KEY (`uid`),\n  UNIQUE KEY `uk_uid` (`uid`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `friend` (\n  `owner_id` varchar(255) NOT NULL,\n  `friend_id` varchar(255) NOT NULL,\n  `comment` varchar(255) DEFAULT NULL,\n  `friend_flag` int(11) NOT NULL,\n  `create_time` datetime NOT NULL,\n  PRIMARY KEY (`owner_id`,`friend_id`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS  `friend_request` (\n  `req_id` varchar(255) NOT NULL,\n  `user_id` varchar(255) NOT NULL,\n  `flag` int(11) NOT NULL DEFAULT '0',\n  `req_message` varchar(255) DEFAULT NULL,\n  `create_time` datetime NOT NULL,\n  PRIMARY KEY (`user_id`,`req_id`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `black_list` (\n  `uid` varchar(32) NOT NULL COMMENT 'uid',\n  `begin_disable_time` datetime DEFAULT NULL,\n  `end_disable_time` datetime DEFAULT NULL,\n  `ex` varchar(1024) DEFAULT NULL,\n  PRIMARY KEY (`uid`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `user_black_list` (\n  `owner_id` varchar(255) NOT NULL,\n  `block_id` varchar(255) NOT NULL,\n  `create_time` datetime NOT NULL,\n  PRIMARY KEY (`owner_id`,`block_id`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `group` (\n  `group_id` varchar(255) NOT NULL,\n  `name` varchar(255) DEFAULT NULL,\n  `introduction` varchar(255) DEFAULT NULL,\n  `notification` varchar(255) DEFAULT NULL,\n  `face_url` varchar(255) DEFAULT NULL,\n  `create_time` datetime DEFAULT NULL,\n  `ex` varchar(255) DEFAULT NULL,\n  PRIMARY KEY (`group_id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `group_member` (\n  `group_id` varchar(255) NOT NULL,\n  `uid` varchar(255) NOT NULL,\n  `nickname` varchar(255) DEFAULT NULL,\n  `user_group_face_url` varchar(255) DEFAULT NULL,\n  `administrator_level` int(11) NOT NULL,\n  `join_time` datetime NOT NULL,\n  PRIMARY KEY (`group_id`,`uid`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS `group_request` (\n  `id` int(11) NOT NULL AUTO_INCREMENT,\n  `group_id` varchar(255) NOT NULL,\n  `from_user_id` varchar(255) NOT NULL,\n  `to_user_id` varchar(255) NOT NULL,\n  `flag` int(10) NOT NULL DEFAULT '0',\n  `req_msg` varchar(255) DEFAULT '',\n  `handled_msg` varchar(255) DEFAULT '',\n  `create_time` datetime NOT NULL,\n  `from_user_nickname` varchar(255) DEFAULT '',\n  `to_user_nickname` varchar(255) DEFAULT NULL,\n  `from_user_face_url` varchar(255) DEFAULT '',\n  `to_user_face_url` varchar(255) DEFAULT '',\n  `handled_user` varchar(255) DEFAULT '',\n  PRIMARY KEY (`id`)\n) ENGINE=InnoDB AUTO_INCREMENT=38 DEFAULT CHARSET=utf8mb4;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+	sqlTable = "CREATE TABLE IF NOT EXISTS  `chat_log` (\n  `msg_id` varchar(128) NOT NULL,\n  `send_id` varchar(255) NOT NULL,\n  `session_type` int(11) NOT NULL,\n  `recv_id` varchar(255) NOT NULL,\n  `content_type` int(11) NOT NULL,\n  `msg_from` int(11) NOT NULL,\n  `content` varchar(1000) NOT NULL,\n  `remark` varchar(100) DEFAULT NULL,\n  `sender_platform_id` int(11) NOT NULL,\n  `send_time` datetime NOT NULL,\n  PRIMARY KEY (`msg_id`) USING BTREE\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;"
+	err = db.Exec(sqlTable).Error
+	if err != nil {
+		panic(err)
+	}
+
+}
+
+func (m *mysqlDB) DefaultGormDB() (*gorm.DB, error) {
+	return m.GormDB(config.Config.Mysql.DBAddress[0], config.Config.Mysql.DBDatabaseName)
+}
+
+func (m *mysqlDB) GormDB(dbAddress, dbName string) (*gorm.DB, error) {
+	m.Lock()
+	defer m.Unlock()
+
+	k := key(dbAddress, dbName)
+	if _, ok := m.dbMap[k]; !ok {
+		if err := m.open(dbAddress, dbName); err != nil {
+			return nil, err
+		}
+	}
+	return m.dbMap[k], nil
+}
+
+func (m *mysqlDB) open(dbAddress, dbName string) error {
+	dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8mb4&parseTime=true&loc=Local",
+		config.Config.Mysql.DBUserName, config.Config.Mysql.DBPassword, dbAddress, dbName)
+	db, err := gorm.Open("mysql", dsn)
+	if err != nil {
+		return err
+	}
+
+	db.SingularTable(true)
+	db.DB().SetMaxOpenConns(config.Config.Mysql.DBMaxOpenConns)
+	db.DB().SetMaxIdleConns(config.Config.Mysql.DBMaxIdleConns)
+	db.DB().SetConnMaxLifetime(time.Duration(config.Config.Mysql.DBMaxLifeTime) * time.Second)
+
+	if m.dbMap == nil {
+		m.dbMap = make(map[string]*gorm.DB)
+	}
+	k := key(dbAddress, dbName)
+	m.dbMap[k] = db
+	return nil
+}

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

@@ -0,0 +1,69 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+	"time"
+)
+
+func InsertToFriend(ownerId, friendId string, flag int32) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertFollow := Friend{
+		OwnerId:    ownerId,
+		FriendId:   friendId,
+		FriendFlag: flag,
+		CreateTime: time.Now(),
+	}
+	err = dbConn.Table("friend").Create(toInsertFollow).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindFriendRelationshipFromFriend(ownerId, friendId string) (*Friend, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friend Friend
+	err = dbConn.Table("friend").Where("owner_id=? and friend_id=?", ownerId, friendId).Find(&friend).Error
+	if err != nil {
+		return nil, err
+	}
+	return &friend, err
+}
+
+func FindUserInfoFromFriend(ownerId string) ([]Friend, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friends []Friend
+	err = dbConn.Table("friend").Where("owner_id=?", ownerId).Find(&friends).Error
+	if err != nil {
+		return nil, err
+	}
+	return friends, nil
+}
+
+func UpdateFriendComment(ownerId, friendId, comment string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("update friend set comment=? where owner_id=? and friend_id=?", comment, ownerId, friendId).Error
+	return err
+}
+
+func DeleteSingleFriendInfo(ownerId, friendId string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("friend").Where("owner_id=? and friend_id=?", ownerId, friendId).Delete(Friend{}).Error
+	return err
+}

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

@@ -0,0 +1,70 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func ReplaceIntoFriendReq(reqId, userId string, flag int32, reqMessage string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("replace into friend_request(req_id,user_id,flag,req_message,create_time) values(?,?,?,?,?)", reqId, userId, flag, reqMessage, time.Now()).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindFriendsApplyFromFriendReq(userId string) ([]FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var usersInfo []FriendRequest
+	//dbConn.LogMode(true)
+	err = dbConn.Table("friend_request").Where("user_id=?", userId).Find(&usersInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return usersInfo, nil
+}
+
+func FindSelfApplyFromFriendReq(userId string) ([]FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var usersInfo []FriendRequest
+	err = dbConn.Table("friend_request").Where("req_id=?", userId).Find(&usersInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return usersInfo, nil
+}
+
+func FindFriendApplyFromFriendReqByUid(reqId, userId string) (*FriendRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var friendRequest FriendRequest
+	err = dbConn.Table("friend_request").Where("req_id=? and user_id=?", reqId, userId).Find(&friendRequest).Error
+	if err != nil {
+		return nil, err
+	}
+	return &friendRequest, nil
+}
+
+func UpdateFriendRelationshipToFriendReq(reqId, userId string, flag int32) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("update friend_request set flag=? where req_id=? and user_id=?", flag, reqId, userId).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}

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

@@ -0,0 +1,217 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func InsertIntoGroupMember(groupId, uid, nickName, userGroupFaceUrl string, administratorLevel int32) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertInfo := GroupMember{GroupId: groupId, Uid: uid, NickName: nickName, AdministratorLevel: administratorLevel, JoinTime: time.Now(), UserGroupFaceUrl: userGroupFaceUrl}
+	err = dbConn.Table("group_member").Create(toInsertInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindGroupMemberListByUserId(uid string) ([]GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []GroupMember
+	err = dbConn.Raw("select * from `group_member` where uid=?", uid).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func FindGroupMemberListByGroupId(groupId string) ([]GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []GroupMember
+	err = dbConn.Raw("select * from `group_member` where group_id=?", groupId).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func FindGroupMemberListByGroupIdAndFilterInfo(groupId string, filter int32) ([]GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	dbConn.LogMode(true)
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []GroupMember
+	err = dbConn.Raw("select * from `group_member` where group_id=? and administrator_level=?", groupId, filter).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+func FindGroupMemberInfoByGroupIdAndUserId(groupId, uid string) (*GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMember GroupMember
+	err = dbConn.Raw("select * from `group_member` where group_id=? and uid=? limit 1", groupId, uid).Scan(&groupMember).Error
+	if err != nil {
+		return nil, err
+	}
+	return &groupMember, nil
+}
+
+func DeleteGroupMemberByGroupIdAndUserId(groupId, uid string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("delete  from `group_member` where group_id=? and uid=?", groupId, uid).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func UpdateOwnerGroupNickName(groupId, userId, groupNickName string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("update `group_member` set nickname=? where group_id=? and uid=?", groupNickName, groupId, userId).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+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
+}
+
+func UpdateTheUserAdministratorLevel(groupId, uid string, administratorLevel int64) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("update `group_member` set administrator_level=? where group_id=? and uid=?", administratorLevel, groupId, uid).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetOwnerManagerByGroupId(groupId string) ([]GroupMember, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupMemberList []GroupMember
+	err = dbConn.Raw("select * from `group_member` where group_id=? and administrator_level > 0", groupId).Find(&groupMemberList).Error
+	if err != nil {
+		return nil, err
+	}
+	return groupMemberList, nil
+}
+
+func IsExistGroupMember(groupId, uid string) bool {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return false
+	}
+	var number int32
+	err = dbConn.Raw("select count(*) from `group_member` where group_id = ? and uid = ?", groupId, uid).Count(&number).Error
+	if err != nil {
+		return false
+	}
+
+	if number != 1 {
+		return false
+	}
+	return true
+}
+
+func RemoveGroupMember(groupId string, memberId string) error {
+	return DeleteGroupMemberByGroupIdAndUserId(groupId, memberId)
+}
+
+func GetMemberInfoById(groupId string, memberId string) (*GroupMember, error) {
+	return FindGroupMemberInfoByGroupIdAndUserId(groupId, memberId)
+}
+
+func GetGroupMemberByGroupId(groupId string, filter int32, begin int32, maxNumber int32) ([]GroupMember, error) {
+	memberList, err := FindGroupMemberListByGroupId(groupId) //sorted by join time
+	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 GetJoinedGroupIdListByMemberId(memberId string) ([]GroupMember, error) {
+	return FindGroupMemberListByUserId(memberId)
+}
+
+func GetGroupMemberNumByGroupId(groupId string) int32 {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return 0
+	}
+	var number int32
+	err = dbConn.Raw("select count(*) from `group_member` where group_id=? ", groupId).Count(&number).Error
+	if err != nil {
+		return 0
+	}
+	return number
+}
+
+func GetGroupOwnerByGroupId(groupId string) string {
+	omList, err := GetOwnerManagerByGroupId(groupId)
+	if err != nil {
+		return ""
+	}
+	for _, v := range omList {
+		if v.AdministratorLevel == 1 {
+			return v.Uid
+		}
+	}
+	return ""
+}
+
+func InsertGroupMember(groupId, userId, nickName, userFaceUrl string, role int32) error {
+	return InsertIntoGroupMember(groupId, userId, nickName, userFaceUrl, role)
+}

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

@@ -0,0 +1,302 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/proto/group"
+	"Open_IM/pkg/common/db"
+	"Open_IM/pkg/common/log"
+	"errors"
+	"time"
+)
+
+func InsertIntoGroup(groupId, name, introduction, notification, faceUrl, ex string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	//Default group name
+	if name == "" {
+		name = "groupChat"
+	}
+	toInsertInfo := Group{GroupId: groupId, Name: name, Introduction: introduction, Notification: notification, FaceUrl: faceUrl, CreateTime: time.Now(), Ex: ex}
+	err = dbConn.Table("group").Create(toInsertInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindGroupInfoByGroupId(groupId string) (*Group, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var groupInfo Group
+	err = dbConn.Raw("select * from `group` where group_id=?", groupId).Scan(&groupInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return &groupInfo, nil
+}
+
+func SetGroupInfo(groupId, groupName, introduction, notification, groupFaceUrl, ex string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	dbConn.LogMode(true)
+	if err != nil {
+		return err
+	}
+	if groupName != "" {
+		if err = dbConn.Exec("update `group` set name=? where group_id=?", groupName, groupId).Error; err != nil {
+			return err
+		}
+	}
+	if introduction != "" {
+		if err = dbConn.Exec("update `group` set introduction=? where group_id=?", introduction, groupId).Error; err != nil {
+			return err
+		}
+	}
+	if notification != "" {
+		if err = dbConn.Exec("update `group` set notification=? where group_id=?", notification, groupId).Error; err != nil {
+			return err
+		}
+	}
+	if groupFaceUrl != "" {
+		if err = dbConn.Exec("update `group` set face_url=? where group_id=?", groupFaceUrl, groupId).Error; err != nil {
+			return err
+		}
+	}
+	if ex != "" {
+		if err = dbConn.Exec("update `group` set ex=? where group_id=?", ex, groupId).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func GetGroupApplicationList(uid string) (*group.GetGroupApplicationListResp, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+
+	var gID string
+	var gIDs []string
+	rows, err := dbConn.Raw("select group_id from `group_member` where uid = ? and administrator_level > 0", uid).Rows()
+	defer rows.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	for rows.Next() {
+		rows.Scan(&gID)
+		gIDs = append(gIDs, gID)
+	}
+
+	if len(gIDs) == 0 {
+		return &group.GetGroupApplicationListResp{}, nil
+	}
+
+	sql := "select id, group_id, from_user_id, to_user_id, flag, req_msg, handled_msg, create_time, " +
+		"from_user_nickname, to_user_nickname, from_user_face_url, to_user_face_url, handled_user  from `group_request` where  group_id in ( "
+	for i := 0; i < len(gIDs); i++ {
+		if i == len(gIDs)-1 {
+			sql = sql + "\"" + gIDs[i] + "\"" + " )"
+		} else {
+			sql = sql + "\"" + gIDs[i] + "\"" + ", "
+		}
+	}
+
+	var groupRequest GroupRequest
+	var groupRequests []GroupRequest
+	log.Info("", "", sql)
+	rows, err = dbConn.Raw(sql).Rows()
+	defer rows.Close()
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		rows.Scan(&groupRequest.ID, &groupRequest.GroupID, &groupRequest.FromUserID, &groupRequest.ToUserID, &groupRequest.Flag, &groupRequest.ReqMsg,
+			&groupRequest.HandledMsg, &groupRequest.CreateTime, &groupRequest.FromUserNickname, &groupRequest.ToUserNickname,
+			&groupRequest.FromUserFaceUrl, &groupRequest.ToUserFaceUrl, &groupRequest.HandledUser)
+		groupRequests = append(groupRequests, groupRequest)
+	}
+
+	reply := &group.GetGroupApplicationListResp{}
+	reply.Data = &group.GetGroupApplicationListData{}
+	reply.Data.Count = int32(len(groupRequests))
+	for i := 0; i < int(reply.Data.Count); i++ {
+		addUser := group.GetGroupApplicationList_Data_User{
+			ID:               groupRequests[i].ID,
+			GroupID:          groupRequests[i].GroupID,
+			FromUserID:       groupRequests[i].FromUserID,
+			FromUserNickname: groupRequests[i].FromUserNickname,
+			FromUserFaceUrl:  groupRequests[i].FromUserFaceUrl,
+			ToUserID:         groupRequests[i].ToUserID,
+			AddTime:          groupRequests[i].CreateTime.Unix(),
+			RequestMsg:       groupRequests[i].ReqMsg,
+			HandledMsg:       groupRequests[i].HandledMsg,
+			Flag:             groupRequests[i].Flag,
+			ToUserNickname:   groupRequests[i].ToUserNickname,
+			ToUserFaceUrl:    groupRequests[i].ToUserFaceUrl,
+			HandledUser:      groupRequests[i].HandledUser,
+			Type:             0,
+			HandleStatus:     0,
+			HandleResult:     0,
+		}
+
+		if addUser.ToUserID != "0" {
+			addUser.Type = 1
+		}
+
+		if len(groupRequests[i].HandledUser) > 0 {
+			if groupRequests[i].HandledUser == uid {
+				addUser.HandleStatus = 2
+			} else {
+				addUser.HandleStatus = 1
+			}
+		}
+
+		if groupRequests[i].Flag == 1 {
+			addUser.HandleResult = 1
+		}
+
+		reply.Data.User = append(reply.Data.User, &addUser)
+	}
+	return reply, nil
+}
+
+func TransferGroupOwner(pb *group.TransferGroupOwnerReq) (*group.TransferGroupOwnerResp, error) {
+	oldOwner, err := FindGroupMemberInfoByGroupIdAndUserId(pb.GroupID, pb.OldOwner)
+	if err != nil {
+		return nil, err
+	}
+	newOwner, err := FindGroupMemberInfoByGroupIdAndUserId(pb.GroupID, pb.NewOwner)
+	if err != nil {
+		return nil, err
+	}
+
+	if oldOwner.Uid == newOwner.Uid {
+		return nil, errors.New("the self")
+	}
+
+	if err = UpdateTheUserAdministratorLevel(pb.GroupID, pb.OldOwner, 0); err != nil {
+		return nil, err
+	}
+
+	if err = UpdateTheUserAdministratorLevel(pb.GroupID, pb.NewOwner, 1); err != nil {
+		UpdateTheUserAdministratorLevel(pb.GroupID, pb.OldOwner, 1)
+		return nil, err
+	}
+
+	return &group.TransferGroupOwnerResp{}, nil
+}
+
+func GroupApplicationResponse(pb *group.GroupApplicationResponseReq) (*group.GroupApplicationResponseResp, 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
+			}
+		}
+	}
+
+	//if err != nil {
+	//	err = dbConn.Raw("select * from `group_request` where handled_user = ? and group_id = ? and to_user_id = ? and from_user_id = ?", "", pb.GroupID, "0", pb.UID).Scan(&groupRequest).Error
+	//	if err != nil {
+	//		return nil, err
+	//	}
+	//	if pb.Flag == 1 {
+	//		err = dbConn.Exec("update `group_request` set flag = ?, handled_msg = ?, handled_user = ? where group_id = ? and to_user_id = ? and from_user_id = ?",
+	//			pb.Flag, pb.RespMsg, pb.OwnerID, pb.GroupID, "0", pb.UID).Error
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//
+	//		// add to group member
+	//		err = InsertIntoGroupMember(pb.GroupID, pb.UID, groupRequest.FromUserNickname, groupRequest.FromUserFaceUrl, 0)
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//	} else if pb.Flag == -1 {
+	//		err = dbConn.Exec("update `group_request` set flag = ?, handled_msg = ?, handled_user = ? where group_id = ? and to_user_id = ? and from_user_id = ?",
+	//			pb.Flag, pb.RespMsg, pb.OwnerID, pb.GroupID, "0", pb.UID).Error
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//	} else {
+	//		return nil, errors.New("flag error")
+	//	}
+	//} else {
+	//	if pb.Flag == 1 {
+	//		err = dbConn.Exec("update `group_request` set flag = ?, handled_msg = ?, handled_user = ? where group_id = ? and to_user_id = ?",
+	//			pb.Flag, pb.RespMsg, pb.OwnerID, pb.GroupID, pb.UID).Error
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//
+	//		// add to group member
+	//		err = InsertIntoGroupMember(pb.GroupID, pb.UID, groupRequest.ToUserNickname, groupRequest.ToUserFaceUrl, 0)
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//	} else if pb.Flag == -1 {
+	//		err = dbConn.Exec("update `group_request` set flag = ?, handled_msg = ?, handled_user = ? where group_id = ? and to_user_id = ?",
+	//			pb.Flag, pb.RespMsg, pb.OwnerID, pb.GroupID, pb.UID).Error
+	//		if err != nil {
+	//			return nil, err
+	//		}
+	//	} else {
+	//		return nil, errors.New("flag error")
+	//	}
+	//}
+
+	return &group.GroupApplicationResponseResp{}, nil
+}

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

@@ -0,0 +1,62 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func InsertIntoGroupRequest(groupId, fromUserId, toUserId, reqMsg, fromUserNickName, fromUserFaceUrl string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertInfo := GroupRequest{GroupID: groupId, FromUserID: fromUserId, ToUserID: toUserId, ReqMsg: reqMsg, FromUserNickname: fromUserNickName, FromUserFaceUrl: fromUserFaceUrl, CreateTime: time.Now()}
+	err = dbConn.Table("group_request").Create(&toInsertInfo).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func FindGroupRequestUserInfoByGroupIDAndUid(groupId, uid string) (*GroupRequest, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var requestUserInfo GroupRequest
+	err = dbConn.Table("group_request").Where("from_user_id=? and group_id=?", uid, groupId).Find(&requestUserInfo).Error
+	if err != nil {
+		return nil, err
+	}
+	return &requestUserInfo, nil
+}
+
+func DelGroupRequest(groupId, fromUserId, toUserId string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("delete from group_request where group_id=? and from_user_id=? and to_user_id=?", groupId, fromUserId, toUserId).Error
+	if err != nil {
+		return err
+	}
+	return 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/model_struct.go

@@ -0,0 +1,70 @@
+package im_mysql_model
+
+import "time"
+
+type User struct {
+	UID        string    `gorm:"column:uid"`
+	Name       string    `gorm:"column:name"`
+	Icon       string    `gorm:"column:icon"`
+	Gender     int32     `gorm:"column:gender"`
+	Mobile     string    `gorm:"column:mobile"`
+	Birth      string    `gorm:"column:birth"`
+	Email      string    `gorm:"column:email"`
+	Ex         string    `gorm:"column:ex"`
+	CreateTime time.Time `gorm:"column:create_time"`
+}
+
+type Friend struct {
+	OwnerId    string    `gorm:"column:owner_id"`
+	FriendId   string    `gorm:"column:friend_id"`
+	Comment    string    `gorm:"column:comment"`
+	FriendFlag int32     `gorm:"column:friend_flag"`
+	CreateTime time.Time `gorm:"column:create_time"`
+}
+type FriendRequest struct {
+	ReqId      string    `gorm:"column:req_id"`
+	Uid        string    `gorm:"column:user_id"`
+	Flag       int32     `gorm:"column:flag"`
+	ReqMessage string    `gorm:"column:req_message"`
+	CreateTime time.Time `gorm:"column:create_time"`
+}
+type BlackList struct {
+	OwnerId    string    `gorm:"column:owner_id"`
+	BlockId    string    `gorm:"column:block_id"`
+	CreateTime time.Time `gorm:"column:create_time"`
+}
+
+type Group struct {
+	GroupId      string    `gorm:"column:group_id"`
+	Name         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"`
+	Ex           string    `gorm:"column:ex"`
+}
+
+type GroupMember struct {
+	GroupId            string    `gorm:"column:group_id"`
+	Uid                string    `gorm:"column:uid"`
+	NickName           string    `gorm:"column:nickname"`
+	AdministratorLevel int32     `gorm:"column:administrator_level"`
+	JoinTime           time.Time `gorm:"column:join_time"`
+	UserGroupFaceUrl   string    `gorm:"user_group_face_url"`
+}
+
+type GroupRequest struct {
+	ID               string    `gorm:"column:id"`
+	GroupID          string    `gorm:"column:group_id"`
+	FromUserID       string    `gorm:"column:from_user_id"`
+	ToUserID         string    `gorm:"column:to_user_id"`
+	Flag             int32     `gorm:"column:flag"`
+	ReqMsg           string    `gorm:"column:req_msg"`
+	HandledMsg       string    `gorm:"column:handled_msg"`
+	CreateTime       time.Time `gorm:"column:create_time"`
+	FromUserNickname string    `gorm:"from_user_nickname"`
+	ToUserNickname   string    `gorm:"to_user_nickname"`
+	FromUserFaceUrl  string    `gorm:"from_user_face_url"`
+	ToUserFaceUrl    string    `gorm:"to_user_face_url"`
+	HandledUser      string    `gorm:"handled_user"`
+}

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

@@ -0,0 +1,48 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func InsertInToUserBlackList(ownerID, blockID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	toInsertInfo := BlackList{OwnerId: ownerID, BlockId: blockID, CreateTime: time.Now()}
+	err = dbConn.Table("user_black_list").Create(toInsertInfo).Error
+	return err
+}
+
+func FindRelationshipFromBlackList(ownerID, blockID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	var blackList BlackList
+	err = dbConn.Table("user_black_list").Where("owner_id=? and block_id=?", ownerID, blockID).Find(&blackList).Error
+	return err
+}
+
+func RemoveBlackList(ownerID, blockID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Exec("delete from user_black_list where owner_id=? and block_id=?", ownerID, blockID).Error
+	return err
+}
+
+func GetBlackListByUID(ownerID string) ([]BlackList, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var blackListUsersInfo []BlackList
+	err = dbConn.Table("user_black_list").Where("owner_id=?", ownerID).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,147 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/db"
+	pbAuth "Open_IM/pkg/proto/auth"
+	"Open_IM/pkg/utils"
+	_ "github.com/jinzhu/gorm/dialects/mysql"
+	"time"
+)
+
+func init() {
+	//init managers
+	var pb pbAuth.UserRegisterReq
+	for k, v := range config.Config.Manager.AppManagerUid {
+		if !IsExistUser(v) {
+			pb.UID = v
+			pb.Name = "AppManager" + utils.IntToString(k+1)
+			err := UserRegister(&pb)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+}
+func UserRegister(pb *pbAuth.UserRegisterReq) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	addUser := User{
+		UID:        pb.UID,
+		Name:       pb.Name,
+		Icon:       pb.Icon,
+		Gender:     pb.Gender,
+		Mobile:     pb.Mobile,
+		Birth:      pb.Birth,
+		Email:      pb.Email,
+		Ex:         pb.Ex,
+		CreateTime: time.Now(),
+	}
+	err = dbConn.Table("user").Create(&addUser).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func UserDelete(uid string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	err = dbConn.Table("user").Where("uid=?", uid).Delete(User{}).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+func FindUserByUID(uid string) (*User, error) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return nil, err
+	}
+	var user User
+	err = dbConn.Table("user").Where("uid=?", uid).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func UpDateUserInfo(uid, name, headUrl, mobilePhoneNum, birth, email, extendInfo string, gender int32) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if name != "" {
+		if err = dbConn.Exec("update user set name=? where uid=?", name, uid).Error; err != nil {
+			return err
+		}
+	}
+	if headUrl != "" {
+		if err = dbConn.Exec("update user set icon=? where uid=?", headUrl, uid).Error; err != nil {
+			return err
+		}
+	}
+	if mobilePhoneNum != "" {
+		if err = dbConn.Exec("update user set mobile=? where uid=?", mobilePhoneNum, uid).Error; err != nil {
+			return err
+		}
+	}
+	if birth != "" {
+		if err = dbConn.Exec("update user set birth=? where uid=?", birth, uid).Error; err != nil {
+			return err
+		}
+	}
+	if email != "" {
+		if err = dbConn.Exec("update user set email=? where uid=?", email, uid).Error; err != nil {
+			return err
+		}
+	}
+	if extendInfo != "" {
+		if err = dbConn.Exec("update user set ex=? where uid=?", extendInfo, uid).Error; err != nil {
+			return err
+		}
+	}
+	if gender != 0 {
+		if err = dbConn.Exec("update user set gender=? where uid=?", gender, uid).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func SelectAllUID() ([]string, error) {
+	var uid []string
+
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return uid, err
+	}
+	rows, _ := dbConn.Raw("select uid from user").Rows()
+	defer rows.Close()
+	var strUID string
+	for rows.Next() {
+		rows.Scan(&strUID)
+		uid = append(uid, strUID)
+	}
+	return uid, nil
+}
+
+func IsExistUser(uid string) bool {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return false
+	}
+	var number int32
+	err = dbConn.Raw("select count(*) from `user` where  uid = ?", uid).Count(&number).Error
+	if err != nil {
+		return false
+	}
+	if number != 1 {
+		return false
+	}
+	return true
+}

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

@@ -0,0 +1,48 @@
+/*
+** 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/db"
+	pbMsg "Open_IM/pkg/proto/chat"
+	"Open_IM/pkg/utils"
+	"database/sql"
+	"time"
+)
+
+// ChatLog Chat information table structure
+type ChatLog struct {
+	MsgId            string         `gorm:"primary_key"`               // Chat history primary key ID
+	SendID           string         `gorm:"column:send_id"`            // Send ID
+	RecvID           string         `gorm:"column:recv_id"`            //Receive ID
+	SendTime         time.Time      `gorm:"column:send_time"`          // Send time
+	SessionType      int32          `gorm:"column:session_type"`       // Session type
+	ContentType      int32          `gorm:"column:content_type"`       // Message content type
+	MsgFrom          int32          `gorm:"column:msg_from"`           // Source, user, system
+	Content          string         `gorm:"column:content"`            // Chat content
+	SenderPlatformID int32          `gorm:"column:sender_platform_id"` //The sender's platform ID
+	Remark           sql.NullString `gorm:"column:remark"`             // remark
+}
+
+func InsertMessageToChatLog(msgData pbMsg.WSToMsgSvrChatMsg) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	chatLog := ChatLog{
+		MsgId:            msgData.MsgID,
+		SendID:           msgData.SendID,
+		RecvID:           msgData.RecvID,
+		SendTime:         utils.UnixNanoSecondToTime(msgData.SendTime),
+		SessionType:      msgData.SessionType,
+		ContentType:      msgData.ContentType,
+		MsgFrom:          msgData.MsgFrom,
+		Content:          msgData.Content,
+		SenderPlatformID: msgData.PlatformID,
+	}
+	return dbConn.Table("chat_log").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
+}

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

@@ -0,0 +1,36 @@
+/*
+** description("").
+** copyright('tuoyun,www.tuoyun.net').
+** author("fg,Gordon@tuoyun.net").
+** time(2021/3/4 11:18).
+ */
+package im_mysql_msg_model
+
+import (
+	"time"
+)
+
+// Receive Inbox table structure
+type Receive struct {
+	UserId     string `gorm:"primary_key"` // 收件箱主键ID
+	Seq        int64  `gorm:"primary_key"` // 收件箱主键ID
+	MsgId      string
+	CreateTime *time.Time
+}
+
+//func InsertMessageToReceive(seq int64, userid, msgid string) error {
+//	conn := db.NewDbConnection()
+//	receive := Receive{
+//		UID: userid,
+//		Seq:    seq,
+//		MsgId:  msgid,
+//	}
+//	err := conn.Table("receive").Create(&receive).Error
+//	return err
+//}
+//func GetBiggestSeqFromReceive(userid string) (seq int64, err error) {
+//	//得到数据库的连接（并非真连接，调用时才连接，由gorm自动维护数据库连接池）
+//	conn := db.NewDbConnection()
+//	err = conn.Raw("select max(seq) from receive where user_id = ?", userid).Row().Scan(&seq)
+//	return seq, err
+//}

pkg/common/db/redisModel.go

@@ -0,0 +1,92 @@
+package db
+
+import (
+	log2 "Open_IM/pkg/common/log"
+	"github.com/garyburd/redigo/redis"
+)
+
+const (
+	userIncrSeq      = "REDIS_USER_INCR_SEQ:" // user incr seq
+	appleDeviceToken = "DEVICE_TOKEN"
+	lastGetSeq       = "LAST_GET_SEQ"
+)
+
+func (d *DataBases) Exec(cmd string, key interface{}, args ...interface{}) (interface{}, error) {
+	con := d.redisPool.Get()
+	if err := con.Err(); err != nil {
+		log2.Error("", "", "redis cmd = %v, err = %v", cmd, err)
+		return nil, err
+	}
+	defer con.Close()
+
+	params := make([]interface{}, 0)
+	params = append(params, key)
+
+	if len(args) > 0 {
+		for _, v := range args {
+			params = append(params, v)
+		}
+	}
+
+	return con.Do(cmd, params...)
+}
+
+//执行用户消息的seq自增操作
+func (d *DataBases) IncrUserSeq(uid string) (int64, error) {
+	key := userIncrSeq + uid
+	return redis.Int64(d.Exec("INCR", key))
+}
+
+//获取最新的seq
+func (d *DataBases) GetUserSeq(uid string) (int64, error) {
+	key := userIncrSeq + uid
+	return redis.Int64(d.Exec("GET", key))
+}
+
+//存储苹果的设备token到redis
+func (d *DataBases) SetAppleDeviceToken(accountAddress, value string) (err error) {
+	key := appleDeviceToken + accountAddress
+	_, err = d.Exec("SET", key, value)
+	return err
+}
+
+//删除苹果设备token
+func (d *DataBases) DelAppleDeviceToken(accountAddress string) (err error) {
+	key := appleDeviceToken + accountAddress
+	_, err = d.Exec("DEL", key)
+	return err
+}
+
+//记录用户上一次主动拉取Seq的值
+func (d *DataBases) SetLastGetSeq(uid string) (err error) {
+	key := lastGetSeq + uid
+	_, err = d.Exec("SET", key)
+	return err
+}
+
+//获取用户上一次主动拉取Seq的值
+func (d *DataBases) GetLastGetSeq(uid string) (int64, error) {
+	key := userIncrSeq + uid
+	return redis.Int64(d.Exec("GET", key))
+}
+
+//Store userid and platform class to redis
+func (d *DataBases) SetUserIDAndPlatform(userID, platformClass, value string, ttl int64) error {
+	key := userID + platformClass
+	_, err := d.Exec("SET", key, value, "EX", ttl)
+	return err
+}
+
+//Check exists userid and platform class from redis
+func (d *DataBases) ExistsUserIDAndPlatform(userID, platformClass string) (interface{}, error) {
+	key := userID + platformClass
+	exists, err := d.Exec("EXISTS", key)
+	return exists, err
+}
+
+//Get platform class Token
+func (d *DataBases) GetPlatformToken(userID, platformClass string) (interface{}, error) {
+	key := userID + platformClass
+	token, err := d.Exec("GET", key)
+	return token, err
+}