update db model

pull/4/head
away 4 years ago
parent 75d308de37
commit 1e4a1dffdd

@ -1,72 +1,60 @@
package db
import (
"Open_IM/src/common/config"
"github.com/garyburd/redigo/redis"
"gopkg.in/mgo.v2"
"time"
)
var DB DataBases
type DataBases struct {
MgoDB mongoDB
RedisDB redisDB
MysqlDB mysqlDB
MysqlDB mysqlDB
mgoSession *mgo.Session
redisPool *redis.Pool
}
func key(dbAddress, dbName string) string {
return dbAddress + "_" + dbName
}
//type Config struct {
// Mongo struct {
// DBAddress []string `yaml:"dbAddress"`
// DBDirect bool `yaml:"dbDirect"`
// DBTimeout int `yaml:"dbTimeout"`
// DBDatabase []string `yaml:"dbDatabase"`
// DBSource string `yaml:"dbSource"`
// DBUserName string `yaml:"dbUserName"`
// DBPassword string `yaml:"dbPassword"`
// DBMaxPoolSize int `yaml:"dbMaxPoolSize"`
// }
// Mysql struct {
// DBAddress []string `yaml:"dbAddress"`
// DBPort int `yaml:"dbPort"`
// DBUserName string `yaml:"dbUserName"`
// DBPassword string `yaml:"dbPassword"`
// DBDatabaseName string `yaml:"dbChatName"` // 默认使用DBAddress[0]
// DBTableName string `yaml:"dbMsgName"`
// DBMsgTableNum int `yaml:"dbMsgTableNum"`
// DBCharset string `yaml:"dbCharset"`
// DBMaxOpenConns int `yaml:"dbMaxOpenConns"`
// DBMaxIdleConns int `yaml:"dbMaxIdleConns"`
// DBMaxLifeTime int `yaml:"dbMaxLifeTime"`
// }
// Redis struct {
// DBAddress string `yaml:"dbAddress"`
// DBPort int `yaml:"dbPort"`
// DBMaxIdle int `yaml:"dbMaxIdle"`
// DBMaxActive int `yaml:"dbMaxActive"`
// DBIdleTimeout int `yaml:"dbIdleTimeout"`
// }
//}
//func init() {
// bytes, err := ioutil.ReadFile("config/db.yaml")
// if err != nil {
// log.Error("", "", "read db.yaml config fail! err = %s", err.Error())
// return
// }
//
// if err = yaml.Unmarshal(bytes, &DB.Config); err != nil {
// log.Error("", "", "unmarshal db.yaml config fail! err = %s", err.Error())
// return
// }
//
// DB.RedisDB.newPool(DB.Config)
// //DB.MysqlDB.sqlxDB(DB.Config.Mysql.DBName[0], DB.Config)
//}
func init() {
DB.RedisDB.newPool()
}
func (d *DataBases) session(dbName string) *mgo.Session {
return d.MgoDB.mgoSession(dbName)
//mysql init
// 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),
)
},
}
}

@ -6,24 +6,30 @@ import (
pbMsg "Open_IM/src/proto/chat"
"errors"
"github.com/golang/protobuf/proto"
"gopkg.in/mgo.v2"
"gopkg.in/mgo.v2/bson"
"time"
)
const cChat = "chat"
type MsgInfo struct {
SendTime int64
Msg []byte
}
type UserChat struct {
UID string
Msg [][]byte
Msg []MsgInfo
}
func (d *DataBases) GetUserChat(uid string, seqBegin, seqEnd int64) (SingleMsg []*pbMsg.MsgFormat, GroupMsg []*pbMsg.MsgFormat, MaxSeq int64, MinSeq int64, err error) {
session := d.session(config.Config.Mongo.DBDatabase[0]).Clone()
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[0]).C("chat")
c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
sChat := UserChat{}
if err = c.Find(bson.M{"uid": uid}).One(&sChat); err != nil {
@ -31,9 +37,8 @@ func (d *DataBases) GetUserChat(uid string, seqBegin, seqEnd int64) (SingleMsg [
}
pChat := pbMsg.MsgSvrToPushSvrChatMsg{}
for i := 0; i < len(sChat.Msg); i++ {
//每次产生新的指针
temp := new(pbMsg.MsgFormat)
if err = proto.Unmarshal(sChat.Msg[i], &pChat); err != nil {
if err = proto.Unmarshal(sChat.Msg[i].Msg, &pChat); err != nil {
return nil, nil, MaxSeq, MinSeq, err
}
if pChat.RecvSeq >= seqBegin && pChat.RecvSeq <= seqEnd {
@ -55,7 +60,6 @@ func (d *DataBases) GetUserChat(uid string, seqBegin, seqEnd int64) (SingleMsg [
if pChat.RecvSeq < MinSeq {
MinSeq = pChat.RecvSeq
}
//单聊消息
if pChat.SessionType == constant.SingleChatType {
SingleMsg = append(SingleMsg, temp)
} else {
@ -64,39 +68,41 @@ func (d *DataBases) GetUserChat(uid string, seqBegin, seqEnd int64) (SingleMsg [
}
}
//d.DelUserChat(&sChat)
return SingleMsg, GroupMsg, MaxSeq, MinSeq, nil
}
func (d *DataBases) SaveUserChat(uid string, m proto.Message) error {
session := d.session(config.Config.Mongo.DBDatabase[0]).Clone()
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()
session.SetMode(mgo.Monotonic, true)
c := session.DB(config.Config.Mongo.DBDatabase[0]).C("chat")
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
bMsg, _ := proto.Marshal(m)
sChat.Msg = append(sChat.Msg, bMsg)
sChat.Msg = append(sChat.Msg, sMsg)
err = c.Insert(&sChat)
if err != nil {
return err
}
} else {
bMsg, err := proto.Marshal(m)
err = c.Update(bson.M{"uid": uid}, bson.M{"$addToSet": bson.M{"msg": bMsg}})
err = c.Update(bson.M{"uid": uid}, bson.M{"$push": bson.M{"msg": sMsg}})
if err != nil {
return err
}
@ -105,85 +111,45 @@ func (d *DataBases) SaveUserChat(uid string, m proto.Message) error {
return nil
}
func (d *DataBases) DelUserChat(uc *UserChat) {
delMaxIndex := 0
pbData := pbMsg.WSToMsgSvrChatMsg{}
for i := 0; i < len(uc.Msg); i++ {
if err := proto.Unmarshal(uc.Msg[i], &pbData); err != nil {
delMaxIndex = i
} else {
if time.Now().Unix()-pbData.SendTime > 7*24*3600 {
delMaxIndex = i
} else {
break
}
}
}
if delMaxIndex > 0 {
uc.Msg = uc.Msg[delMaxIndex:]
session := d.session(config.Config.Mongo.DBDatabase[0]).Clone()
if session == nil {
return
}
defer session.Close()
c := session.DB(config.Config.Mongo.DBDatabase[0]).C("chat")
if err := c.Update(bson.M{"uid": uc.UID}, bson.M{"msg": uc.Msg}); err != nil {
return
}
}
}
func (d *DataBases) DelHistoryChat(days int64, ids []string) error {
session := d.session(config.Config.Mongo.DBDatabase[0]).Clone()
func (d *DataBases) DelUserChat(uid string) error {
session := d.mgoSession.Clone()
if session == nil {
return errors.New("mgo session == nil")
return errors.New("session == nil")
}
defer session.Close()
c := session.DB(config.Config.Mongo.DBDatabase[0]).C("chat")
c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
for i := 0; i < len(ids); i++ {
d.delHistoryUserChat(c, days, ids[i])
//time.Sleep(1 * time.Millisecond)
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) delHistoryUserChat(c *mgo.Collection, days int64, id string) error {
sChat := UserChat{}
if err := c.Find(bson.M{"uid": id}).One(&sChat); err != nil {
return err
func (d *DataBases) MgoUserCount() (int, error) {
session := d.mgoSession.Clone()
if session == nil {
return 0, errors.New("session == nil")
}
defer session.Close()
delMaxIndex := 0
pbData := pbMsg.WSToMsgSvrChatMsg{}
for i := 0; i < len(sChat.Msg); i++ {
if err := proto.Unmarshal(sChat.Msg[i], &pbData); err != nil {
delMaxIndex = i
} else {
if time.Now().Unix()-pbData.SendTime > int64(days)*24*3600 {
delMaxIndex = i
} else {
break
}
}
}
c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
if delMaxIndex > 0 {
if delMaxIndex < len(sChat.Msg) {
sChat.Msg = sChat.Msg[delMaxIndex:]
} else {
sChat.Msg = sChat.Msg[0:0]
}
return c.Find(nil).Count()
}
if err := c.Update(bson.M{"uid": sChat.UID}, bson.M{"msg": sChat.Msg}); err != nil {
return err
}
func (d *DataBases) MgoSkipUID(count int) (string, error) {
session := d.mgoSession.Clone()
if session == nil {
return "", errors.New("session == nil")
}
defer session.Close()
return nil
c := session.DB(config.Config.Mongo.DBDatabase).C(cChat)
sChat := UserChat{}
c.Find(nil).Skip(count).Limit(1).One(&sChat)
return sChat.UID, nil
}

@ -42,7 +42,6 @@ func FindUserInfoFromFriend(ownerId string) ([]Friend, error) {
if err != nil {
return nil, err
}
//dbConn.LogMode(true)
var friends []Friend
err = dbConn.Table("friend").Where("owner_id=?", ownerId).Find(&friends).Error
if err != nil {

@ -31,7 +31,20 @@ func FindFriendsApplyFromFriendReq(userId string) ([]FriendRequest, error) {
return usersInfo, nil
}
func FindFriendRelationshipFromFriendReq(reqId, userId string) (*FriendRequest, error) {
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

@ -1,26 +1,30 @@
package im_mysql_model
import "Open_IM/src/common/db"
import (
"Open_IM/src/common/db"
"time"
)
func InsertIntoGroupMember(groupId, userId string, isAdmin int64) error {
func InsertIntoGroupMember(groupId, uid, nickName, userGroupFaceUrl string, administratorLevel int32) error {
dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil {
return err
}
err = dbConn.Exec("insert into `group_member`(group_id,user_id,is_admin) values(?,?,?)", groupId, userId, isAdmin).Error
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(userId string) ([]GroupMember, error) {
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 user_id=?", userId).Find(&groupMemberList).Error
err = dbConn.Raw("select * from `group_member` where uid=?", uid).Find(&groupMemberList).Error
if err != nil {
return nil, err
}
@ -40,25 +44,38 @@ func FindGroupMemberListByGroupId(groupId string) ([]GroupMember, error) {
return groupMemberList, nil
}
func FindGroupMemberInfoByGroupIdAndUserId(groupId, userId string) (*GroupMember, error) {
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 user_id=? limit 1", groupId, userId).Scan(&groupMember).Error
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, userId string) error {
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 user_id=?", groupId, userId).Error
err = dbConn.Exec("delete from `group_member` where group_id=? and uid=?", groupId, uid).Error
if err != nil {
return err
}
@ -70,7 +87,7 @@ func UpdateOwnerGroupNickName(groupId, userId, groupNickName string) error {
if err != nil {
return err
}
err = dbConn.Exec("update `group_member` set nickname=? where group_id=? and user_id=?", groupNickName, groupId, userId).Error
err = dbConn.Exec("update `group_member` set nickname=? where group_id=? and uid=?", groupNickName, groupId, userId).Error
if err != nil {
return err
}
@ -96,3 +113,88 @@ func SelectGroupList(groupID string) ([]string, error) {
}
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 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 == 2 {
return v.Uid
}
}
return ""
}
func InsertGroupMember(groupId, userId, nickName, userFaceUrl string, role int32) error {
return InsertIntoGroupMember(groupId, userId, nickName, userFaceUrl, role)
}

@ -1,8 +1,14 @@
package im_mysql_model
import "Open_IM/src/common/db"
import (
"Open_IM/src/common/db"
"Open_IM/src/common/log"
"Open_IM/src/proto/group"
"errors"
"time"
)
func InsertIntoGroup(groupId, name, groupHeadUrl string) error {
func InsertIntoGroup(groupId, name, introduction, notification, faceUrl string) error {
dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil {
return err
@ -11,7 +17,8 @@ func InsertIntoGroup(groupId, name, groupHeadUrl string) error {
if name == "" {
name = "groupChat"
}
err = dbConn.Exec("insert into `group`(group_id,name,head_url) values(?,?,?)", groupId, name, groupHeadUrl).Error
toInsertInfo := Group{GroupId: groupId, Name: name, Introduction: introduction, Notification: notification, FaceUrl: faceUrl, CreateTime: time.Now()}
err = dbConn.Table("group").Create(toInsertInfo).Error
if err != nil {
return err
}
@ -31,37 +38,253 @@ func FindGroupInfoByGroupId(groupId string) (*Group, error) {
return &groupInfo, nil
}
func UpdateGroupName(groupId, groupName string) (err error) {
func SetGroupInfo(groupId, groupName, introduction, notification, groupFaceUrl, ex string) error {
dbConn, err := db.DB.MysqlDB.DefaultGormDB()
dbConn.LogMode(true)
if err != nil {
return err
}
err = dbConn.Exec("update `group` set name=? where group_id=?", groupName, groupId).Error
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 UpdateGroupBulletin(groupId, bulletinContent string) (err error) {
func GetGroupApplicationList(uid string) (*group.GetGroupApplicationListResp, error) {
dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil {
return err
return nil, err
}
err = dbConn.Exec("update `group` set bulletin=? where group_id=?", bulletinContent, groupId).Error
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 err
return nil, err
}
return nil
for rows.Next() {
rows.Scan(&gID)
gIDs = append(gIDs, gID)
}
if len(gIDs) == 0 {
return &group.GetGroupApplicationListResp{}, nil
}
sql := "select group_id, from_user_id, to_user_id, flag, req_msg, handled_msg, create_time, from_user_nickname, from_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.GroupID, &groupRequest.FromUserID, &groupRequest.ToUserID, &groupRequest.Flag, &groupRequest.ReqMsg,
&groupRequest.HandledMsg, &groupRequest.CreateTime, &groupRequest.FromUserNickname, &groupRequest.FromUserFaceUrl, &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{
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,
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 UpdateGroupHeadImage(groupId, headImageUrl string) (err error) {
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 {
return nil, err
}
if ownerUser.AdministratorLevel <= 0 {
return nil, errors.New("insufficient permissions")
}
dbConn, err := db.DB.MysqlDB.DefaultGormDB()
if err != nil {
return err
return nil, err
}
err = dbConn.Exec("update `group` set head_url=? where group_id=?", headImageUrl, groupId).Error
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 {
return err
return nil, err
}
return nil
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 {
return nil, err
}
if saveFlag == 1 {
if groupRequest.ToUserID == "0" {
err = InsertIntoGroupMember(pb.GroupID, pb.FromUserID, groupRequest.FromUserNickname, groupRequest.FromUserFaceUrl, 0)
if err != nil {
return nil, err
}
} else {
err = InsertIntoGroupMember(pb.GroupID, pb.ToUserID, groupRequest.ToUserNickname, groupRequest.ToUserFaceUrl, 0)
if err != nil {
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
}

@ -0,0 +1,62 @@
package im_mysql_model
import (
"Open_IM/src/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 FindGroupRequestUserInfoByUidAndGroupID(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
}

@ -23,7 +23,7 @@ type Friend struct {
}
type FriendRequest struct {
ReqId string `gorm:"column:req_id"`
UserId string `gorm:"column:user_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"`
@ -33,16 +33,37 @@ type BlackList struct {
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"`
HeadURL string `gorm:"column:head_url"`
Bulletin string `gorm:"column:bulletin"`
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"`
UserId string `gorm:"column:user_id"`
NickName string `gorm:"column:nickname"`
IsAdmin int32 `gorm:"column:is_admin"`
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 {
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"`
}

@ -1,6 +1,7 @@
package db
import (
log2 "Open_IM/src/common/log"
"github.com/garyburd/redigo/redis"
)
@ -10,62 +11,82 @@ const (
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.RedisDB.Exec("INCR", key))
return redis.Int64(d.Exec("INCR", key))
}
//获取最新的seq
func (d *DataBases) GetUserSeq(uid string) (int64, error) {
key := userIncrSeq + uid
return redis.Int64(d.RedisDB.Exec("GET", key))
return redis.Int64(d.Exec("GET", key))
}
//存储苹果的设备token到redis
func (d *DataBases) SetAppleDeviceToken(accountAddress, value string) (err error) {
key := appleDeviceToken + accountAddress
_, err = d.RedisDB.Exec("SET", key, value)
_, err = d.Exec("SET", key, value)
return err
}
//删除苹果设备token
func (d *DataBases) DelAppleDeviceToken(accountAddress string) (err error) {
key := appleDeviceToken + accountAddress
_, err = d.RedisDB.Exec("DEL", key)
_, err = d.Exec("DEL", key)
return err
}
//记录用户上一次主动拉取Seq的值
func (d *DataBases) SetLastGetSeq(uid string) (err error) {
key := lastGetSeq + uid
_, err = d.RedisDB.Exec("SET", key)
_, err = d.Exec("SET", key)
return err
}
//获取用户上一次主动拉取Seq的值
func (d *DataBases) GetLastGetSeq(uid string) (int64, error) {
key := userIncrSeq + uid
return redis.Int64(d.RedisDB.Exec("GET", key))
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.RedisDB.Exec("SET", key, value, "EX", ttl)
_, 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.RedisDB.Exec("EXISTS", key)
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.RedisDB.Exec("GET", key)
token, err := d.Exec("GET", key)
return token, err
}

Loading…
Cancel
Save