IM/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2026-05-04 17:15:58 +08:00
Code Issues Packages Projects Releases Wiki Activity

groupdb

Browse Source
This commit is contained in:
wangchuxiao
2023-01-16 20:14:26 +08:00
parent 80b22e0e0e
commit 822db2a63e
35 changed files with 590 additions and 686 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/common/db/mysql/chat_log_model.go
+104
View File
@@ -0,0 +1,104 @@
package mysql
import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
pbMsg "Open_IM/pkg/proto/msg"
server_api_params "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"fmt"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
"github.com/jinzhu/copier"
"gorm.io/gorm"
"time"
)
var ChatLogDB *gorm.DB
type ChatLog struct {
ServerMsgID string `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"`
ClientMsgID string `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"`
SendID string `gorm:"column:send_id;type:char(64);index:send_id,priority:2" json:"sendID"`
RecvID string `gorm:"column:recv_id;type:char(64);index:recv_id,priority:2" json:"recvID"`
SenderPlatformID int32 `gorm:"column:sender_platform_id" json:"senderPlatformID"`
SenderNickname string `gorm:"column:sender_nick_name;type:varchar(255)" json:"senderNickname"`
SenderFaceURL string `gorm:"column:sender_face_url;type:varchar(255);" json:"senderFaceURL"`
SessionType int32 `gorm:"column:session_type;index:session_type,priority:2;index:session_type_alone" json:"sessionType"`
MsgFrom int32 `gorm:"column:msg_from" json:"msgFrom"`
ContentType int32 `gorm:"column:content_type;index:content_type,priority:2;index:content_type_alone" json:"contentType"`
Content string `gorm:"column:content;type:varchar(3000)" json:"content"`
Status int32 `gorm:"column:status" json:"status"`
SendTime time.Time `gorm:"column:send_time;index:sendTime;index:content_type,priority:1;index:session_type,priority:1;index:recv_id,priority:1;index:send_id,priority:1" json:"sendTime"`
CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
}
func (ChatLog) TableName() string {
return "chat_logs"
}
func InsertMessageToChatLog(msg pbMsg.MsgDataToMQ) error {
chatLog := new(ChatLog)
copier.Copy(chatLog, msg.MsgData)
switch msg.MsgData.SessionType {
case constant.GroupChatType, constant.SuperGroupChatType:
chatLog.RecvID = msg.MsgData.GroupID
case constant.SingleChatType:
chatLog.RecvID = msg.MsgData.RecvID
}
if msg.MsgData.ContentType >= constant.NotificationBegin && msg.MsgData.ContentType <= constant.NotificationEnd {
var tips 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 db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Create(chatLog).Error
}
func GetChatLog(chatLog *ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []ChatLog, error) {
mdb := ChatLogDB.Table("chat_logs")
if chatLog.SendTime.Unix() > 0 {
mdb = mdb.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
}
if chatLog.Content != "" {
mdb = mdb.Where(" content like ? ", fmt.Sprintf("%%%s%%", chatLog.Content))
}
if chatLog.SessionType == 1 {
mdb = mdb.Where("session_type = ?", chatLog.SessionType)
} else if chatLog.SessionType == 2 {
mdb = mdb.Where("session_type in (?)", []int{constant.GroupChatType, constant.SuperGroupChatType})
}
if chatLog.ContentType != 0 {
mdb = mdb.Where("content_type = ?", chatLog.ContentType)
}
if chatLog.SendID != "" {
mdb = mdb.Where("send_id = ?", chatLog.SendID)
}
if chatLog.RecvID != "" {
mdb = mdb.Where("recv_id = ?", chatLog.RecvID)
}
if len(contentTypeList) > 0 {
mdb = mdb.Where("content_type in (?)", contentTypeList)
}
var count int64
if err := mdb.Count(&count).Error; err != nil {
return 0, nil, err
}
var chatLogs []ChatLog
mdb = mdb.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1)))
if err := mdb.Find(&chatLogs).Error; err != nil {
return 0, nil, err
}
return count, chatLogs, nil
}
pkg/common/db/mysql/conversation_model.go
+123
View File
@@ -0,0 +1,123 @@
package mysql
import (
"gorm.io/gorm"
)
var ConversationDB *gorm.DB
type Conversation struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;type:char(128)" json:"OwnerUserID"`
ConversationID string `gorm:"column:conversation_id;primary_key;type:char(128)" json:"conversationID"`
ConversationType int32 `gorm:"column:conversation_type" json:"conversationType"`
UserID string `gorm:"column:user_id;type:char(64)" json:"userID"`
GroupID string `gorm:"column:group_id;type:char(128)" json:"groupID"`
RecvMsgOpt int32 `gorm:"column:recv_msg_opt" json:"recvMsgOpt"`
UnreadCount int32 `gorm:"column:unread_count" json:"unreadCount"`
DraftTextTime int64 `gorm:"column:draft_text_time" json:"draftTextTime"`
IsPinned bool `gorm:"column:is_pinned" json:"isPinned"`
IsPrivateChat bool `gorm:"column:is_private_chat" json:"isPrivateChat"`
BurnDuration int32 `gorm:"column:burn_duration;default:30" json:"burnDuration"`
GroupAtType int32 `gorm:"column:group_at_type" json:"groupAtType"`
IsNotInGroup bool `gorm:"column:is_not_in_group" json:"isNotInGroup"`
UpdateUnreadCountTime int64 `gorm:"column:update_unread_count_time" json:"updateUnreadCountTime"`
AttachedInfo string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
}
func (Conversation) TableName() string {
return "conversations"
}
func SetConversation(conversation Conversation) (bool, error) {
var isUpdate bool
newConversation := conversation
if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
return isUpdate, ConversationDB.Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record
} else {
//force update
isUpdate = true
return isUpdate, ConversationDB.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
Updates(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt, "is_pinned": conversation.IsPinned, "is_private_chat": conversation.IsPrivateChat,
"group_at_type": conversation.GroupAtType, "is_not_in_group": conversation.IsNotInGroup}).Error
}
}
func SetOneConversation(conversation Conversation) error {
return ConversationDB.Model(&Conversation{}).Create(&conversation).Error
}
func PeerUserSetConversation(conversation Conversation) error {
newConversation := conversation
if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
return ConversationDB.Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record
}
//force update
return ConversationDB.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
Updates(map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}).Error
}
func SetRecvMsgOpt(conversation Conversation) (bool, error) {
var isUpdate bool
newConversation := conversation
if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
return isUpdate, ConversationDB.Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record
} else {
//force update
isUpdate = true
return isUpdate, ConversationDB.Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID).
Updates(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt}).Error
}
}
func GetUserAllConversations(ownerUserID string) ([]Conversation, error) {
var conversations []Conversation
err := ConversationDB.Where("owner_user_id=?", ownerUserID).Find(&conversations).Error
return conversations, err
}
func GetMultipleUserConversationByConversationID(ownerUserIDList []string, conversationID string) ([]Conversation, error) {
var conversations []Conversation
err := ConversationDB.Where("owner_user_id IN ? and conversation_id=?", ownerUserIDList, conversationID).Find(&conversations).Error
return conversations, err
}
func GetExistConversationUserIDList(ownerUserIDList []string, conversationID string) ([]string, error) {
var resultArr []string
err := ConversationDB.Table("conversations").Where(" owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Pluck("owner_user_id", &resultArr).Error
if err != nil {
return nil, err
}
return resultArr, nil
}
func GetConversation(OwnerUserID, conversationID string) (Conversation, error) {
var conversation Conversation
err := ConversationDB.Table("conversations").Where("owner_user_id=? and conversation_id=?", OwnerUserID, conversationID).Take(&conversation).Error
return conversation, err
}
func GetConversations(OwnerUserID string, conversationIDs []string) ([]Conversation, error) {
var conversations []Conversation
err := ConversationDB.Model(&Conversation{}).Where("conversation_id IN (?) and owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error
return conversations, err
}
func GetConversationsByConversationIDMultipleOwner(OwnerUserIDList []string, conversationID string) ([]Conversation, error) {
var conversations []Conversation
err := ConversationDB.Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", OwnerUserIDList, conversationID).Find(&conversations).Error
return conversations, err
}
func UpdateColumnsConversations(ownerUserIDList []string, conversationID string, args map[string]interface{}) error {
return ConversationDB.Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Updates(args).Error
}
func GetConversationIDListByUserID(userID string) ([]string, error) {
var IDList []string
err := ConversationDB.Model(&Conversation{}).Where("owner_user_id=?", userID).Pluck("conversation_id", &IDList).Error
return IDList, err
}
pkg/common/db/mysql/demo_model.go
+42
View File
@@ -0,0 +1,42 @@
package mysql
import (
"gorm.io/gorm"
)
var RegisterDB *gorm.DB
type Register struct {
Account string `gorm:"column:account;primary_key;type:char(255)" json:"account"`
Password string `gorm:"column:password;type:varchar(255)" json:"password"`
Ex string `gorm:"column:ex;size:1024" json:"ex"`
UserID string `gorm:"column:user_id;type:varchar(255)" json:"userID"`
AreaCode string `gorm:"column:area_code;type:varchar(255)"`
InvitationCode string `gorm:"column:invitation_code;type:varchar(255)"`
RegisterIP string `gorm:"column:register_ip;type:varchar(255)"`
}
func GetRegister(account, areaCode, userID string) (*Register, error) {
var r Register
return &r, RegisterDB.Table("registers").Where("user_id = ? and user_id != ? or account = ? or account =? and area_code=?",
userID, "", account, account, areaCode).Take(&r).Error
}
func SetPassword(account, password, ex, userID, areaCode, ip string) error {
r := Register{
Account: account,
Password: password,
Ex: ex,
UserID: userID,
RegisterIP: ip,
AreaCode: areaCode,
}
return RegisterDB.Table("registers").Create(&r).Error
}
func ResetPassword(account, password string) error {
r := Register{
Password: password,
}
return RegisterDB.Table("registers").Where("account = ?", account).Updates(&r).Error
}
pkg/common/db/mysql/file_model.go
+50
View File
@@ -0,0 +1,50 @@
package mysql
import (
"gorm.io/gorm"
"time"
)
var AppDB *gorm.DB
type AppVersion struct {
Version string `gorm:"column:version;size:64" json:"version"`
Type int `gorm:"column:type;primary_key" json:"type"`
UpdateTime int `gorm:"column:update_time" json:"update_time"`
ForceUpdate bool `gorm:"column:force_update" json:"force_update"`
FileName string `gorm:"column:file_name" json:"file_name"`
YamlName string `gorm:"column:yaml_name" json:"yaml_name"`
UpdateLog string `gorm:"column:update_log" json:"update_log"`
}
func (AppVersion) TableName() string {
return "app_version"
}
func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, yamlName, updateLog string) error {
updateTime := int(time.Now().Unix())
app := AppVersion{
Version: version,
Type: appType,
UpdateTime: updateTime,
FileName: fileName,
YamlName: yamlName,
ForceUpdate: forceUpdate,
UpdateLog: updateLog,
}
result := AppDB.Model(AppVersion{}).Where("type = ?", appType).Updates(map[string]interface{}{"force_update": forceUpdate,
"version": version, "update_time": int(time.Now().Unix()), "file_name": fileName, "yaml_name": yamlName, "type": appType, "update_log": updateLog})
if result.Error != nil {
return result.Error
}
if result.RowsAffected == 0 {
err := AppDB.Create(&app).Error
return err
}
return nil
}
func GetNewestVersion(appType int) (*AppVersion, error) {
app := AppVersion{}
return &app, AppDB.Model(AppVersion{}).First(&app, appType).Error
}
pkg/common/db/mysql/friend_model.go
+83
View File
@@ -0,0 +1,83 @@
package mysql
import (
"fmt"
"time"
)
func InsertToFriend(toInsertFollow *Friend) error {
toInsertFollow.CreateTime = time.Now()
err := FriendDB.Table("friends").Create(toInsertFollow).Error
if err != nil {
return err
}
return nil
}
func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
var friend Friend
err := FriendDB.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) ([]Friend, error) {
var friends []Friend
var x Friend
x.OwnerUserID = OwnerUserID
err := FriendDB.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) {
var friendIDList []string
err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
if err != nil {
return nil, err
}
return friendIDList, nil
}
func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
return FriendDB.Exec("update friends set remark=? where owner_user_id=? and friend_user_id=?", Remark, OwnerUserID, FriendUserID).Error
}
func DeleteSingleFriendInfo(OwnerUserID, FriendUserID string) error {
return FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(Friend{}).Error
}
type FriendUser struct {
Friend
Nickname string `gorm:"column:name;size:255"`
}
func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumber int32) (friendUserList []*FriendUser, count int64, err error) {
db := FriendDB.Table("friends").
Select("friends.*, users.name").
Where("friends.owner_user_id=?", ownerUserID).Limit(int(showNumber)).
Joins("left join users on friends.friend_user_id = users.user_id").
Offset(int(showNumber * (pageNumber - 1)))
if friendUserName != "" {
db = db.Where("users.name like ?", fmt.Sprintf("%%%s%%", friendUserName))
}
if err = db.Count(&count).Error; err != nil {
return
}
err = db.Find(&friendUserList).Error
return
}
func GetFriendByIDCMS(ownerUserID, friendUserID string) (friendUser *FriendUser, err error) {
friendUser = &FriendUser{}
err = FriendDB.Table("friends").
Select("friends.*, users.name").
Where("friends.owner_user_id=? and friends.friend_user_id=?", ownerUserID, friendUserID).
Joins("left join users on friends.friend_user_id = users.user_id").
Take(friendUser).Error
return friendUser, err
}
pkg/common/db/mysql/friend_model_k.go
+69
View File
@@ -0,0 +1,69 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
type Friend struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
FriendUserID string `gorm:"column:friend_user_id;primary_key;size:64"`
Remark string `gorm:"column:remark;size:255"`
CreateTime time.Time `gorm:"column:create_time"`
AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func NewFriend(db *gorm.DB) *Friend {
return &Friend{db: db}
}
func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
err = utils.Wrap(f.db.Create(&friends).Error, "")
return err
}
func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
}()
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
return err
}
func (f *Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}()
return utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
}
func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
return utils.Wrap(f.db.Updates(&friends).Error, "")
}
func (f *Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
}()
err = utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
return friends, err
}
func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) {
friend = &Friend{}
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend)
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
return friend, err
}
pkg/common/db/mysql/friend_request_model.go
+144
View File
@@ -0,0 +1,144 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
var FriendRequestDB *gorm.DB
type FriendRequest struct {
FromUserID string `gorm:"column:from_user_id;primary_key;size:64"`
ToUserID string `gorm:"column:to_user_id;primary_key;size:64"`
HandleResult int32 `gorm:"column:handle_result"`
ReqMsg string `gorm:"column:req_msg;size:255"`
CreateTime time.Time `gorm:"column:create_time"`
HandlerUserID string `gorm:"column:handler_user_id;size:64"`
HandleMsg string `gorm:"column:handle_msg;size:255"`
HandleTime time.Time `gorm:"column:handle_time"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func NewFriendRequest(db *gorm.DB) *FriendRequest {
return &FriendRequest{db: db}
}
func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
err = utils.Wrap(f.db.Create(&friends).Error, "")
return err
}
func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
}()
err = utils.Wrap(f.db.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
return err
}
func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}()
return utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
}
func (f *FriendRequest) Update(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}()
return utils.Wrap(f.db.Updates(&friends).Error, "")
}
func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends []*FriendRequest, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
}()
err = utils.Wrap(f.db.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
return friends, err
}
func (f *FriendRequest) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *FriendRequest, err error) {
friend = &FriendRequest{}
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *friend)
err = utils.Wrap(f.db.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
return friend, err
}
// who apply to add me
func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest, error) {
var usersInfo []FriendRequest
err := FriendRequestDB.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) ([]FriendRequest, error) {
var usersInfo []FriendRequest
err := FriendRequestDB.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) (*FriendRequest, error) {
var friendRequest FriendRequest
err := FriendRequestDB.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 *FriendRequest) error {
friendRequest.CreateTime = time.Now()
return FriendRequestDB.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
friendRequest.FromUserID, friendRequest.ToUserID).Updates(&friendRequest).Error
}
func InsertFriendApplication(friendRequest *FriendRequest, args map[string]interface{}) error {
if err := FriendRequestDB.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 := FriendRequestDB.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 := FriendRequestDB.Table("friend_requests").Create(friendRequest).Error
if err != nil {
return err
}
return nil
}
pkg/common/db/mysql/group_member_model.go
+234
View File
@@ -0,0 +1,234 @@
package mysql
//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 GroupMember) error {
// toInsertInfo.JoinTime = time.Now()
// if toInsertInfo.RoleLevel == 0 {
// toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
// }
// toInsertInfo.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Create(toInsertInfo).Error
// if err != nil {
// return err
// }
// return nil
//}
//func BatchInsertIntoGroupMember(toInsertInfoList []*GroupMember) error {
// for _, toInsertInfo := range toInsertInfoList {
// toInsertInfo.JoinTime = time.Now()
// if toInsertInfo.RoleLevel == 0 {
// toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
// }
// toInsertInfo.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
// }
// return db.DB.MysqlDB.DefaultGormDB().Create(toInsertInfoList).Error
//
//}
//
//func GetGroupMemberListByUserID(userID string) ([]GroupMember, error) {
// var groupMemberList []GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("user_id=?", userID).Find(&groupMemberList).Error
// if err != nil {
// return nil, err
// }
// return groupMemberList, nil
//}
//
//func GetGroupMemberListByGroupID(groupID string) ([]GroupMember, error) {
// var groupMemberList []GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().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) {
// var groupMemberIDList []string
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=?", groupID).Pluck("user_id", &groupMemberIDList).Error
// if err != nil {
// return nil, err
// }
// return groupMemberIDList, nil
//}
//
//func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([]GroupMember, error) {
// var groupMemberList []GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().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) (*GroupMember, error) {
// var groupMember GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().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 {
// return db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=? and user_id=? ", groupID, userID).Delete(GroupMember{}).Error
//}
//
//func DeleteGroupMemberByGroupID(groupID string) error {
// return db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=? ", groupID).Delete(GroupMember{}).Error
//}
//
//func UpdateGroupMemberInfo(groupMemberInfo GroupMember) error {
// return db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=? and user_id=?", groupMemberInfo.GroupID, groupMemberInfo.UserID).Updates(&groupMemberInfo).Error
//}
//
//func UpdateGroupMemberInfoByMap(groupMemberInfo GroupMember, m map[string]interface{}) error {
// return db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=? and user_id=?", groupMemberInfo.GroupID, groupMemberInfo.UserID).Updates(m).Error
//}
//
//func GetOwnerManagerByGroupID(groupID string) ([]GroupMember, error) {
// var groupMemberList []GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().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) (int64, error) {
// var number int64
// err := db.DB.MysqlDB.DefaultGormDB().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) (*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(constant.ErrNoGroupOwner, "")
//}
//
//func IsExistGroupMember(groupID, userID string) bool {
// var number int64
// err := db.DB.MysqlDB.DefaultGormDB().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 GetGroupMemberByGroupID(groupID string, filter int32, begin int32, maxNumber int32) ([]GroupMember, error) {
// var memberList []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
// 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) ([]GroupMember, error) {
// var groupMembers []GroupMember
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&groupMembers).Error
// if err != nil {
// return nil, err
// }
// return groupMembers, nil
//}
//
//func GetGroupMembersCount(groupID, userName string) (int64, error) {
// var count int64
// if err := db.DB.MysqlDB.DefaultGormDB().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 GroupMember, args map[string]interface{}) error {
// return db.DB.MysqlDB.DefaultGormDB().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/group_member_model_k.go
+295
View File
@@ -0,0 +1,295 @@
package mysql
import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"fmt"
"gorm.io/gorm"
"time"
)
var GroupMemberDB *gorm.DB
type GroupMember struct {
GroupID string `gorm:"column:group_id;primary_key;size:64"`
UserID string `gorm:"column:user_id;primary_key;size:64"`
Nickname string `gorm:"column:nickname;size:255"`
FaceURL string `gorm:"column:user_group_face_url;size:255"`
RoleLevel int32 `gorm:"column:role_level"`
JoinTime time.Time `gorm:"column:join_time"`
JoinSource int32 `gorm:"column:join_source"`
InviterUserID string `gorm:"column:inviter_user_id;size:64"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
MuteEndTime time.Time `gorm:"column:mute_end_time"`
Ex string `gorm:"column:ex;size:1024"`
DB *gorm.DB
}
func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
}()
return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "")
}
func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
}()
return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "")
}
func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
}()
return utils.Wrap(GroupMemberDB.Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
}
func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember) (err error) {
defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "")
}
func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
}()
var where [][]interface{}
for _, groupMember := range groupMembers {
where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
}
err = utils.Wrap(GroupMemberDB.Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
return groupList, err
}
func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMember, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
}()
groupMember = &GroupMember{}
return groupMember, utils.Wrap(GroupMemberDB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
}
func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
}()
groupMember = &GroupMember{}
err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error
return groupMember, utils.Wrap(err, "")
}
func InsertIntoGroupMember(toInsertInfo GroupMember) error {
toInsertInfo.JoinTime = time.Now()
if toInsertInfo.RoleLevel == 0 {
toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
}
toInsertInfo.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
err := GroupMemberDB.Table("group_members").Create(toInsertInfo).Error
if err != nil {
return err
}
return nil
}
func BatchInsertIntoGroupMember(toInsertInfoList []*GroupMember) error {
for _, toInsertInfo := range toInsertInfoList {
toInsertInfo.JoinTime = time.Now()
if toInsertInfo.RoleLevel == 0 {
toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers
}
toInsertInfo.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
}
return GroupMemberDB.Create(toInsertInfoList).Error
}
func GetGroupMemberListByUserID(userID string) ([]GroupMember, error) {
var groupMemberList []GroupMember
err := GroupMemberDB.Table("group_members").Where("user_id=?", userID).Find(&groupMemberList).Error
if err != nil {
return nil, err
}
return groupMemberList, nil
}
func GetGroupMemberListByGroupID(groupID string) ([]GroupMember, error) {
var groupMemberList []GroupMember
err := GroupMemberDB.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) {
var groupMemberIDList []string
err := GroupMemberDB.Table("group_members").Where("group_id=?", groupID).Pluck("user_id", &groupMemberIDList).Error
if err != nil {
return nil, err
}
return groupMemberIDList, nil
}
func GetGroupMemberListByGroupIDAndRoleLevel(groupID string, roleLevel int32) ([]GroupMember, error) {
var groupMemberList []GroupMember
err := GroupMemberDB.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) (*GroupMember, error) {
var groupMember GroupMember
err := GroupMemberDB.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 {
return GroupMemberDB.Table("group_members").Where("group_id=? and user_id=? ", groupID, userID).Delete(GroupMember{}).Error
}
func DeleteGroupMemberByGroupID(groupID string) error {
return GroupMemberDB.Table("group_members").Where("group_id=? ", groupID).Delete(GroupMember{}).Error
}
func UpdateGroupMemberInfo(groupMemberInfo GroupMember) error {
return GroupMemberDB.Table("group_members").Where("group_id=? and user_id=?", groupMemberInfo.GroupID, groupMemberInfo.UserID).Updates(&groupMemberInfo).Error
}
func UpdateGroupMemberInfoByMap(groupMemberInfo GroupMember, m map[string]interface{}) error {
return GroupMemberDB.Table("group_members").Where("group_id=? and user_id=?", groupMemberInfo.GroupID, groupMemberInfo.UserID).Updates(m).Error
}
func GetOwnerManagerByGroupID(groupID string) ([]GroupMember, error) {
var groupMemberList []GroupMember
err := GroupMemberDB.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) (int64, error) {
var number int64
err := GroupMemberDB.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) (*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(constant.ErrGroupNoOwner, "")
}
func IsExistGroupMember(groupID, userID string) bool {
var number int64
err := GroupMemberDB.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 CheckIsExistGroupMember(ctx context.Context, groupID, userID string) error {
var number int64
err := GroupMemberDB.Table("group_members").Where("group_id = ? and user_id = ?", groupID, userID).Count(&number).Error
if err != nil {
return constant.ErrDB.Wrap()
}
if number != 1 {
return constant.ErrData.Wrap()
}
return nil
}
func GetGroupMemberByGroupID(groupID string, filter int32, begin int32, maxNumber int32) ([]GroupMember, error) {
var memberList []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
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) ([]GroupMember, error) {
var groupMembers []GroupMember
err := GroupMemberDB.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&groupMembers).Error
if err != nil {
return nil, err
}
return groupMembers, nil
}
func GetGroupMembersCount(groupID, userName string) (int64, error) {
var count int64
if err := GroupMemberDB.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 GroupMember, args map[string]interface{}) error {
return GroupMemberDB.Model(groupMemberInfo).Updates(args).Error
}
pkg/common/db/mysql/group_model.go
+98
View File
@@ -0,0 +1,98 @@
package mysql
import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/utils"
"fmt"
"time"
)
func InsertIntoGroup(groupInfo Group) error {
if groupInfo.GroupName == "" {
groupInfo.GroupName = "Group Chat"
}
groupInfo.CreateTime = time.Now()
if groupInfo.NotificationUpdateTime.Unix() < 0 {
groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0)
}
err := GroupDB.Create(groupInfo).Error
if err != nil {
return err
}
return nil
}
func TakeGroupInfoByGroupID(groupID string) (*Group, error) {
var groupInfo Group
err := GroupDB.Where("group_id=?", groupID).Take(&groupInfo).Error
return &groupInfo, err
}
func GetGroupInfoByGroupID(groupID string) (*Group, error) {
var groupInfo Group
err := GroupDB.Where("group_id=?", groupID).Take(&groupInfo).Error
return &groupInfo, err
}
func SetGroupInfo(groupInfo Group) error {
return GroupDB.Where("group_id=?", groupInfo.GroupID).Updates(&groupInfo).Error
}
type GroupWithNum struct {
Group
MemberCount int `gorm:"column:num"`
}
func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]GroupWithNum, int64, error) {
var groups []GroupWithNum
var count int64
sql := GroupDB.Select("groups.*, (select count(*) from group_members where group_members.group_id=groups.group_id) as num").
Where(" name like ? and status != ?", fmt.Sprintf("%%%s%%", groupName), constant.GroupStatusDismissed)
if err := sql.Count(&count).Error; err != nil {
return nil, 0, err
}
err := sql.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&groups).Error
return groups, count, err
}
func GetGroups(pageNumber, showNumber int) ([]GroupWithNum, error) {
var groups []GroupWithNum
if err := GroupDB.Select("groups.*, (select count(*) from group_members where group_members.group_id=groups.group_id) as num").
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 := Group{
GroupID: groupId,
Status: groupStatus,
}
if err := SetGroupInfo(group); err != nil {
return err
}
return nil
}
func GetGroupsCountNum(group Group) (int32, error) {
var count int64
if err := GroupDB.Where(" name like ? ", fmt.Sprintf("%%%s%%", group.GroupName)).Count(&count).Error; err != nil {
return 0, err
}
return int32(count), nil
}
func UpdateGroupInfoDefaultZero(groupID string, args map[string]interface{}) error {
return GroupDB.Where("group_id = ? ", groupID).Updates(args).Error
}
func GetGroupIDListByGroupType(groupType int) ([]string, error) {
var groupIDList []string
if err := GroupDB.Where("group_type = ? ", groupType).Pluck("group_id", &groupIDList).Error; err != nil {
return nil, err
}
return groupIDList, nil
}
pkg/common/db/mysql/group_model_k.go
+80
View File
@@ -0,0 +1,80 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
type Group struct {
GroupID string `gorm:"column:group_id;primary_key;size:64" json:"groupID" binding:"required"`
GroupName string `gorm:"column:name;size:255" json:"groupName"`
Notification string `gorm:"column:notification;size:255" json:"notification"`
Introduction string `gorm:"column:introduction;size:255" json:"introduction"`
FaceURL string `gorm:"column:face_url;size:255" json:"faceURL"`
CreateTime time.Time `gorm:"column:create_time;index:create_time"`
Ex string `gorm:"column:ex" json:"ex;size:1024" json:"ex"`
Status int32 `gorm:"column:status"`
CreatorUserID string `gorm:"column:creator_user_id;size:64"`
GroupType int32 `gorm:"column:group_type"`
NeedVerification int32 `gorm:"column:need_verification"`
LookMemberInfo int32 `gorm:"column:look_member_info" json:"lookMemberInfo"`
ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"`
NotificationUpdateTime time.Time `gorm:"column:notification_update_time"`
NotificationUserID string `gorm:"column:notification_user_id;size:64"`
DB *gorm.DB
}
func NewGroupDB() *Group {
var group Group
group.DB = initMysqlDB(&group)
return &group
}
func (*Group) Create(ctx context.Context, groups []*Group) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
}()
err = utils.Wrap(GroupDB.Create(&groups).Error, "")
return err
}
func (*Group) Delete(ctx context.Context, groupIDs []string) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs)
}()
return utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "")
}
func (*Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args)
}()
return utils.Wrap(GroupDB.Where("group_id = ?", groupID).Updates(args).Error, "")
}
func (*Group) Update(ctx context.Context, groups []*Group) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
}()
return utils.Wrap(GroupDB.Updates(&groups).Error, "")
}
func (*Group) Find(ctx context.Context, groupIDs []string) (groups []*Group, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups)
}()
err = utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
return groups, err
}
func (*Group) Take(ctx context.Context, groupID string) (group *Group, err error) {
group = &Group{}
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
}()
err = utils.Wrap(GroupDB.Where("group_id = ?", groupID).Take(group).Error, "")
return group, err
}
pkg/common/db/mysql/group_request_model.go
+158
View File
@@ -0,0 +1,158 @@
package mysql
//
//func UpdateGroupRequest(groupRequest GroupRequest) error {
// if groupRequest.HandledTime.Unix() < 0 {
// groupRequest.HandledTime = utils.UnixSecondToTime(0)
// }
// return db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=? and user_id=?", groupRequest.GroupID, groupRequest.UserID).Updates(&groupRequest).Error
//}
//
//func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
// DelGroupRequestByGroupIDAndUserID(toInsertInfo.GroupID, toInsertInfo.UserID)
// if toInsertInfo.HandledTime.Unix() < 0 {
// toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
// }
// u := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=? and user_id=?", toInsertInfo.GroupID, toInsertInfo.UserID).Updates(&toInsertInfo)
// if u.RowsAffected != 0 {
// return nil
// }
//
// toInsertInfo.ReqTime = time.Now()
// if toInsertInfo.HandledTime.Unix() < 0 {
// toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
// }
//
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Create(&toInsertInfo).Error
// if err != nil {
// return err
// }
// return nil
//}
//
//func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, error) {
// var groupRequest GroupRequest
// err := db.DB.MysqlDB.DefaultGormDB().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 {
// return db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=? and user_id=?", groupID, userID).Delete(GroupRequest{}).Error
//}
//
//func GetGroupRequestByGroupID(groupID string) ([]GroupRequest, error) {
// var groupRequestList []GroupRequest
// err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=?", groupID).Find(&groupRequestList).Error
// if err != nil {
// return nil, err
// }
// return groupRequestList, nil
//}
//
//received
//func GetRecvGroupApplicationList(userID string) ([]GroupRequest, error) {
// var groupRequestList []GroupRequest
// memberList, err := GetGroupMemberListByUserID(userID)
// if err != nil {
// return nil, utils.Wrap(err, utils.GetSelfFuncName())
// }
// for _, v := range memberList {
// if v.RoleLevel > constant.GroupOrdinaryUsers {
// list, err := GetGroupRequestByGroupID(v.GroupID)
// if err != nil {
// continue
// }
// groupRequestList = append(groupRequestList, list...)
// }
// }
// return groupRequestList, nil
//}
//
//func GetUserReqGroupByUserID(userID string) ([]GroupRequest, error) {
// var groupRequestList []GroupRequest
// err := db.DB.MysqlDB.DefaultGormDB().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/group_request_model_k.go
+76
View File
@@ -0,0 +1,76 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
var GroupRequestDB *gorm.DB
type GroupRequest struct {
UserID string `gorm:"column:user_id;primary_key;size:64"`
GroupID string `gorm:"column:group_id;primary_key;size:64"`
HandleResult int32 `gorm:"column:handle_result"`
ReqMsg string `gorm:"column:req_msg;size:1024"`
HandledMsg string `gorm:"column:handle_msg;size:1024"`
ReqTime time.Time `gorm:"column:req_time"`
HandleUserID string `gorm:"column:handle_user_id;size:64"`
HandledTime time.Time `gorm:"column:handle_time"`
JoinSource int32 `gorm:"column:join_source"`
InviterUserID string `gorm:"column:inviter_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
}
func (GroupRequest) TableName() string {
return "friend_requests"
}
func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}()
return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName())
}
func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}()
return utils.Wrap(GroupRequestDB.Delete(&groupRequests).Error, utils.GetSelfFuncName())
}
func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
}()
return utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Updates(args).Error, utils.GetSelfFuncName())
}
func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}()
return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName())
}
func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests)
}()
var where [][]interface{}
for _, groupMember := range groupRequests {
where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
}
return resultGroupRequests, utils.Wrap(GroupRequestDB.Where("(group_id, user_id) in ?", where).Find(&resultGroupRequests).Error, utils.GetSelfFuncName())
}
func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) {
groupRequest = &GroupRequest{}
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest)
}()
return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
}
pkg/common/db/mysql/init_mysql.go
+67
View File
@@ -0,0 +1,67 @@
package mysql
import (
"Open_IM/pkg/common/config"
"fmt"
"time"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
func initMysqlDB(model interface{}) *gorm.DB {
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")
var db *gorm.DB
db, err := gorm.Open(mysql.Open(dsn), nil)
if err != nil {
time.Sleep(time.Duration(30) * time.Second)
db, err = gorm.Open(mysql.Open(dsn), nil)
if err != nil {
panic(err.Error() + " open failed " + dsn)
}
}
sql := fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8 COLLATE utf8_general_ci;", config.Config.Mysql.DBDatabaseName)
err = db.Exec(sql).Error
if err != nil {
panic(err.Error() + " Exec failed:" + sql)
}
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)
newLogger := logger.New(
Writer{},
logger.Config{
SlowThreshold: time.Duration(config.Config.Mysql.SlowThreshold) * time.Millisecond, // Slow SQL threshold
LogLevel: logger.LogLevel(config.Config.Mysql.LogLevel), // Log level
IgnoreRecordNotFoundError: true, // Ignore ErrRecordNotFound error for logger
Colorful: true, // Disable color
},
)
db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
Logger: newLogger,
})
if err != nil {
panic(err.Error() + " Open failed " + dsn)
}
sqlDB, err := db.DB()
if err != nil {
panic(err.Error() + " db.DB() failed ")
}
sqlDB.SetConnMaxLifetime(time.Second * time.Duration(config.Config.Mysql.DBMaxLifeTime))
sqlDB.SetMaxOpenConns(config.Config.Mysql.DBMaxOpenConns)
sqlDB.SetMaxIdleConns(config.Config.Mysql.DBMaxIdleConns)
//models := []interface{}{&Friend{}, &FriendRequest{}, &Group{}, &GroupMember{}, &GroupRequest{},
// &User{}, &Black{}, &ChatLog{}, &Conversation{}, &AppVersion{}}
db.AutoMigrate(model)
db.Set("gorm:table_options", "CHARSET=utf8")
db.Set("gorm:table_options", "collation=utf8_unicode_ci")
_ = db.Migrator().CreateTable(model)
return db.Model(model)
}
type Writer struct{}
func (w Writer) Printf(format string, args ...interface{}) {
fmt.Printf(format, args...)
}
pkg/common/db/mysql/model_struct.go
+275
View File
@@ -0,0 +1,275 @@
package mysql
//type Register struct {
// Account string `gorm:"column:account;primary_key;type:char(255)" json:"account"`
// Password string `gorm:"column:password;type:varchar(255)" json:"password"`
// Ex string `gorm:"column:ex;size:1024" json:"ex"`
// UserID string `gorm:"column:user_id;type:varchar(255)" json:"userID"`
// AreaCode string `gorm:"column:area_code;type:varchar(255)"`
// InvitationCode string `gorm:"column:invitation_code;type:varchar(255)"`
// RegisterIP string `gorm:"column:register_ip;type:varchar(255)"`
//}
//type Invitation struct {
// InvitationCode string `gorm:"column:invitation_code;primary_key;type:varchar(32)"`
// CreateTime time.Time `gorm:"column:create_time"`
// UserID string `gorm:"column:user_id;index:userID"`
// LastTime time.Time `gorm:"column:last_time"`
// Status int32 `gorm:"column:status"`
//}
// message FriendInfo{
// string OwnerUserID = 1;
// string Remark = 2;
// int64 CreateTime = 3;
// UserInfo FriendUser = 4;
// int32 AddSource = 5;
// string OperatorUserID = 6;
// string Ex = 7;
// }
// open_im_sdk.FriendInfo(FriendUser) != imdb.Friend(FriendUserID)
//type Friend struct {
// OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
// FriendUserID string `gorm:"column:friend_user_id;primary_key;size:64"`
// Remark string `gorm:"column:remark;size:255"`
// CreateTime time.Time `gorm:"column:create_time"`
// AddSource int32 `gorm:"column:add_source"`
// OperatorUserID string `gorm:"column:operator_user_id;size:64"`
// Ex string `gorm:"column:ex;size:1024"`
//}
// message FriendRequest{
// string FromUserID = 1;
// string ToUserID = 2;
// int32 HandleResult = 3;
// string ReqMsg = 4;
// int64 CreateTime = 5;
// string HandlerUserID = 6;
// string HandleMsg = 7;
// int64 HandleTime = 8;
// string Ex = 9;
// }
// open_im_sdk.FriendRequest(nickname, farce url ...) != imdb.FriendRequest
//type FriendRequest struct {
// FromUserID string `gorm:"column:from_user_id;primary_key;size:64"`
// ToUserID string `gorm:"column:to_user_id;primary_key;size:64"`
// HandleResult int32 `gorm:"column:handle_result"`
// ReqMsg string `gorm:"column:req_msg;size:255"`
// CreateTime time.Time `gorm:"column:create_time"`
// HandlerUserID string `gorm:"column:handler_user_id;size:64"`
// HandleMsg string `gorm:"column:handle_msg;size:255"`
// HandleTime time.Time `gorm:"column:handle_time"`
// Ex string `gorm:"column:ex;size:1024"`
//}
//
//func (FriendRequest) TableName() string {
// return "friend_requests"
//}
// message GroupInfo{
// string GroupID = 1;
// string GroupName = 2;
// string Notification = 3;
// string Introduction = 4;
// string FaceUrl = 5;
// string OwnerUserID = 6;
// uint32 MemberCount = 8;
// int64 CreateTime = 7;
// string Ex = 9;
// int32 Status = 10;
// string CreatorUserID = 11;
// int32 GroupType = 12;
// }
//
// open_im_sdk.GroupInfo (OwnerUserID , MemberCount )> imdb.Group
//type Group struct {
// //`json:"operationID" binding:"required"`
// //`protobuf:"bytes,1,opt,name=GroupID" json:"GroupID,omitempty"` `json:"operationID" binding:"required"`
// GroupID string `gorm:"column:group_id;primary_key;size:64" json:"groupID" binding:"required"`
// GroupName string `gorm:"column:name;size:255" json:"groupName"`
// Notification string `gorm:"column:notification;size:255" json:"notification"`
// Introduction string `gorm:"column:introduction;size:255" json:"introduction"`
// FaceURL string `gorm:"column:face_url;size:255" json:"faceURL"`
// CreateTime time.Time `gorm:"column:create_time;index:create_time"`
// Ex string `gorm:"column:ex" json:"ex;size:1024" json:"ex"`
// Status int32 `gorm:"column:status"`
// CreatorUserID string `gorm:"column:creator_user_id;size:64"`
// GroupType int32 `gorm:"column:group_type"`
// NeedVerification int32 `gorm:"column:need_verification"`
// LookMemberInfo int32 `gorm:"column:look_member_info" json:"lookMemberInfo"`
// ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"`
// NotificationUpdateTime time.Time `gorm:"column:notification_update_time"`
// NotificationUserID string `gorm:"column:notification_user_id;size:64"`
// DB *gorm.DB `gorm:"-" json:"-"`
//}
// message GroupMemberFullInfo {
// string GroupID = 1 ;
// string UserID = 2 ;
// int32 roleLevel = 3;
// int64 JoinTime = 4;
// string NickName = 5;
// string FaceUrl = 6;
// int32 JoinSource = 8;
// string OperatorUserID = 9;
// string Ex = 10;
// int32 AppMangerLevel = 7; //if >0
// } open_im_sdk.GroupMemberFullInfo(AppMangerLevel) > imdb.GroupMember
//type GroupMember struct {
// GroupID string `gorm:"column:group_id;primary_key;size:64"`
// UserID string `gorm:"column:user_id;primary_key;size:64"`
// Nickname string `gorm:"column:nickname;size:255"`
// FaceURL string `gorm:"column:user_group_face_url;size:255"`
// RoleLevel int32 `gorm:"column:role_level"`
// JoinTime time.Time `gorm:"column:join_time"`
// JoinSource int32 `gorm:"column:join_source"`
// InviterUserID string `gorm:"column:inviter_user_id;size:64"`
// OperatorUserID string `gorm:"column:operator_user_id;size:64"`
// MuteEndTime time.Time `gorm:"column:mute_end_time"`
// Ex string `gorm:"column:ex;size:1024"`
//}
// message GroupRequest{
// string UserID = 1;
// string GroupID = 2;
// string HandleResult = 3;
// string ReqMsg = 4;
// string HandleMsg = 5;
// int64 ReqTime = 6;
// string HandleUserID = 7;
// int64 HandleTime = 8;
// string Ex = 9;
// }open_im_sdk.GroupRequest == imdb.GroupRequest
//type GroupRequest struct {
// UserID string `gorm:"column:user_id;primary_key;size:64"`
// GroupID string `gorm:"column:group_id;primary_key;size:64"`
// HandleResult int32 `gorm:"column:handle_result"`
// ReqMsg string `gorm:"column:req_msg;size:1024"`
// HandledMsg string `gorm:"column:handle_msg;size:1024"`
// ReqTime time.Time `gorm:"column:req_time"`
// HandleUserID string `gorm:"column:handle_user_id;size:64"`
// HandledTime time.Time `gorm:"column:handle_time"`
// JoinSource int32 `gorm:"column:join_source"`
// InviterUserID string `gorm:"column:inviter_user_id;size:64"`
// Ex string `gorm:"column:ex;size:1024"`
//}
// string UserID = 1;
// string Nickname = 2;
// string FaceUrl = 3;
// int32 Gender = 4;
// string PhoneNumber = 5;
// string Birth = 6;
// string Email = 7;
// string Ex = 8;
// string CreateIp = 9;
// int64 CreateTime = 10;
// int32 AppMangerLevel = 11;
// open_im_sdk.User == imdb.User
//type User struct {
// UserID string `gorm:"column:user_id;primary_key;size:64"`
// Nickname string `gorm:"column:name;size:255"`
// FaceURL string `gorm:"column:face_url;size:255"`
// Gender int32 `gorm:"column:gender"`
// PhoneNumber string `gorm:"column:phone_number;size:32"`
// Birth time.Time `gorm:"column:birth"`
// Email string `gorm:"column:email;size:64"`
// Ex string `gorm:"column:ex;size:1024"`
// CreateTime time.Time `gorm:"column:create_time;index:create_time"`
// AppMangerLevel int32 `gorm:"column:app_manger_level"`
// GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"`
//
// status int32 `gorm:"column:status"`
//}
//type UserIpRecord struct {
// UserID string `gorm:"column:user_id;primary_key;size:64"`
// CreateIp string `gorm:"column:create_ip;size:15"`
// LastLoginTime time.Time `gorm:"column:last_login_time"`
// LastLoginIp string `gorm:"column:last_login_ip;size:15"`
// LoginTimes int32 `gorm:"column:login_times"`
//}
//
//// ip limit login
//type IpLimit struct {
// Ip string `gorm:"column:ip;primary_key;size:15"`
// LimitRegister int32 `gorm:"column:limit_register;size:1"`
// LimitLogin int32 `gorm:"column:limit_login;size:1"`
// CreateTime time.Time `gorm:"column:create_time"`
// LimitTime time.Time `gorm:"column:limit_time"`
//}
//
//// ip login
//type UserIpLimit struct {
// UserID string `gorm:"column:user_id;primary_key;size:64"`
// Ip string `gorm:"column:ip;primary_key;size:15"`
// CreateTime time.Time `gorm:"column:create_time"`
//}
// message BlackInfo{
// string OwnerUserID = 1;
// int64 CreateTime = 2;
// PublicUserInfo BlackUserInfo = 4;
// int32 AddSource = 5;
// string OperatorUserID = 6;
// string Ex = 7;
// }
// open_im_sdk.BlackInfo(BlackUserInfo) != imdb.Black (BlockUserID)
//type Black struct {
// OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
// BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"`
// CreateTime time.Time `gorm:"column:create_time"`
// AddSource int32 `gorm:"column:add_source"`
// OperatorUserID string `gorm:"column:operator_user_id;size:64"`
// Ex string `gorm:"column:ex;size:1024"`
//}
//type ChatLog struct {
// ServerMsgID string `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"`
// ClientMsgID string `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"`
// SendID string `gorm:"column:send_id;type:char(64);index:send_id,priority:2" json:"sendID"`
// RecvID string `gorm:"column:recv_id;type:char(64);index:recv_id,priority:2" json:"recvID"`
// SenderPlatformID int32 `gorm:"column:sender_platform_id" json:"senderPlatformID"`
// SenderNickname string `gorm:"column:sender_nick_name;type:varchar(255)" json:"senderNickname"`
// SenderFaceURL string `gorm:"column:sender_face_url;type:varchar(255);" json:"senderFaceURL"`
// SessionType int32 `gorm:"column:session_type;index:session_type,priority:2;index:session_type_alone" json:"sessionType"`
// MsgFrom int32 `gorm:"column:msg_from" json:"msgFrom"`
// ContentType int32 `gorm:"column:content_type;index:content_type,priority:2;index:content_type_alone" json:"contentType"`
// Content string `gorm:"column:content;type:varchar(3000)" json:"content"`
// Status int32 `gorm:"column:status" json:"status"`
// SendTime time.Time `gorm:"column:send_time;index:sendTime;index:content_type,priority:1;index:session_type,priority:1;index:recv_id,priority:1;index:send_id,priority:1" json:"sendTime"`
// CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
// Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
//}
//
//func (ChatLog) TableName() string {
// return "chat_logs"
//}
//type BlackList struct {
// UserId string `gorm:"column:uid"`
// BeginDisableTime time.Time `gorm:"column:begin_disable_time"`
// EndDisableTime time.Time `gorm:"column:end_disable_time"`
//}
//type Conversation struct {
// OwnerUserID string `gorm:"column:owner_user_id;primary_key;type:char(128)" json:"OwnerUserID"`
// ConversationID string `gorm:"column:conversation_id;primary_key;type:char(128)" json:"conversationID"`
// ConversationType int32 `gorm:"column:conversation_type" json:"conversationType"`
// UserID string `gorm:"column:user_id;type:char(64)" json:"userID"`
// GroupID string `gorm:"column:group_id;type:char(128)" json:"groupID"`
// RecvMsgOpt int32 `gorm:"column:recv_msg_opt" json:"recvMsgOpt"`
// UnreadCount int32 `gorm:"column:unread_count" json:"unreadCount"`
// DraftTextTime int64 `gorm:"column:draft_text_time" json:"draftTextTime"`
// IsPinned bool `gorm:"column:is_pinned" json:"isPinned"`
// IsPrivateChat bool `gorm:"column:is_private_chat" json:"isPrivateChat"`
// BurnDuration int32 `gorm:"column:burn_duration;default:30" json:"burnDuration"`
// GroupAtType int32 `gorm:"column:group_at_type" json:"groupAtType"`
// IsNotInGroup bool `gorm:"column:is_not_in_group" json:"isNotInGroup"`
// UpdateUnreadCountTime int64 `gorm:"column:update_unread_count_time" json:"updateUnreadCountTime"`
// AttachedInfo string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"`
// Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
//}
//func (Conversation) TableName() string {
// return "conversations"
//}
pkg/common/db/mysql/statistics_model.go
+102
View File
@@ -0,0 +1,102 @@
package mysql
import (
"Open_IM/pkg/common/constant"
"time"
)
func GetActiveUserNum(from, to time.Time) (int32, error) {
var num int64
err := ChatLogDB.Table("chat_logs").Select("count(distinct(send_id))").Where("send_time >= ? and send_time <= ?", from, to).Count(&num).Error
return int32(num), err
}
func GetIncreaseUserNum(from, to time.Time) (int32, error) {
var num int64
err := UserDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
return int32(num), err
}
func GetTotalUserNum() (int32, error) {
var num int64
err := UserDB.Count(&num).Error
return int32(num), err
}
func GetTotalUserNumByDate(to time.Time) (int32, error) {
var num int64
err := UserDB.Where("create_time <= ?", to).Count(&num).Error
return int32(num), err
}
func GetPrivateMessageNum(from, to time.Time) (int32, error) {
var num int64
err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 1).Count(&num).Error
return int32(num), err
}
func GetGroupMessageNum(from, to time.Time) (int32, error) {
var num int64
err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 2).Count(&num).Error
return int32(num), err
}
func GetIncreaseGroupNum(from, to time.Time) (int32, error) {
var num int64
err := GroupDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
return int32(num), err
}
func GetTotalGroupNum() (int32, error) {
var num int64
err := GroupDB.Count(&num).Error
return int32(num), err
}
func GetGroupNum(to time.Time) (int32, error) {
var num int64
err := GroupDB.Where("create_time <= ?", to).Count(&num).Error
return int32(num), err
}
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) {
var activeGroups []*activeGroup
err := ChatLogDB.Select("recv_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.GroupChatType, constant.SuperGroupChatType}).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error
for _, activeGroup := range activeGroups {
group := Group{
GroupID: activeGroup.Id,
}
GroupDB.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) {
var activeUsers []*activeUser
err := ChatLogDB.Select("send_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, constant.SingleChatType).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error
for _, activeUser := range activeUsers {
user := User{
UserID: activeUser.ID,
}
err = UserDB.Select("user_id, name").Find(&user).Error
if err != nil {
continue
}
activeUser.Name = user.Nickname
activeUser.ID = user.UserID
}
return activeUsers, err
}
pkg/common/db/mysql/user_black_list_model.go
+112
View File
@@ -0,0 +1,112 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
type Black struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"`
CreateTime time.Time `gorm:"column:create_time"`
AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
db *gorm.DB `gorm:"-"`
}
func NewBlack(db *gorm.DB) *Black {
return &Black{db: db}
}
func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(b.db.Create(&blacks).Error, "")
}
func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "")
}
func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
}()
return utils.Wrap(b.db.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
}
func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(b.db.Updates(&blacks).Error, "")
}
func (b *Black) Find(ctx context.Context, blacks []Black) (blackList []*Black, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
}()
var where [][]interface{}
for _, black := range blacks {
where = append(where, []interface{}{black.OwnerUserID, black.BlockUserID})
}
return blackList, utils.Wrap(GroupMemberDB.Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
}
func (b *Black) Take(ctx context.Context, blackID string) (black *Black, err error) {
black = &Black{}
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blackID", blackID, "black", *black)
}()
return black, utils.Wrap(b.db.Where("black_id = ?", blackID).Take(black).Error, "")
}
func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
}()
return blackList, utils.Wrap(GroupMemberDB.Where("owner_user_id = ?", ownerUserID).Find(&blackList).Error, "")
}
func InsertInToUserBlackList(ctx context.Context, black Black) (err error) {
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black)
black.CreateTime = time.Now()
err = BlackDB.Create(black).Error
return err
}
func CheckBlack(ownerUserID, blockUserID string) error {
var black Black
return BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Find(&black).Error
}
func RemoveBlackList(ownerUserID, blockUserID string) error {
err := BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Delete(Black{}).Error
return utils.Wrap(err, "RemoveBlackList failed")
}
func GetBlackListByUserID(ownerUserID string) ([]Black, error) {
var blackListUsersInfo []Black
err := BlackDB.Where("owner_user_id=?", ownerUserID).Find(&blackListUsersInfo).Error
if err != nil {
return nil, err
}
return blackListUsersInfo, nil
}
func GetBlackIDListByUserID(ownerUserID string) ([]string, error) {
var blackIDList []string
err := b.db.Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
if err != nil {
return nil, err
}
return blackIDList, nil
}
pkg/common/db/mysql/user_model.go
+209
View File
@@ -0,0 +1,209 @@
package mysql
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/utils"
"fmt"
"gorm.io/gorm"
"time"
)
var (
BlackListDB *gorm.DB
UserDB *gorm.DB
)
func InitManager() {
for k, v := range config.Config.Manager.AppManagerUid {
_, err := GetUserByUserID(v)
if err != nil {
} else {
continue
}
var appMgr User
appMgr.UserID = v
if k == 0 {
appMgr.Nickname = config.Config.Manager.AppSysNotificationName
} else {
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)
} else {
fmt.Println("AppManager insert ", appMgr)
}
}
}
func UserRegister(user User) error {
user.CreateTime = time.Now()
if user.AppMangerLevel == 0 {
user.AppMangerLevel = constant.AppOrdinaryUsers
}
if user.Birth.Unix() < 0 {
user.Birth = utils.UnixSecondToTime(0)
}
err := UserDB.Table("users").Create(&user).Error
if err != nil {
return err
}
return nil
}
func GetAllUser() ([]User, error) {
var userList []User
err := UserDB.Table("users").Find(&userList).Error
return userList, err
}
func TakeUserByUserID(userID string) (*User, error) {
var user User
err := UserDB.Table("users").Where("user_id=?", userID).Take(&user).Error
if err != nil {
return nil, err
}
return &user, nil
}
func GetUserByUserID(userID string) (*User, error) {
var user User
err := UserDB.Table("users").Where("user_id=?", userID).Take(&user).Error
if err != nil {
return nil, err
}
return &user, nil
}
func GetUsersByUserIDList(userIDList []string) ([]*User, error) {
var userList []*User
err := UserDB.Table("users").Where("user_id in (?)", userIDList).Find(&userList).Error
return userList, err
}
func GetUserNameByUserID(userID string) (string, error) {
var user User
err := UserDB.Table("users").Select("name").Where("user_id=?", userID).First(&user).Error
if err != nil {
return "", err
}
return user.Nickname, nil
}
func UpdateUserInfo(user User) error {
return UserDB.Where("user_id=?", user.UserID).Updates(&user).Error
}
func UpdateUserInfoByMap(user User, m map[string]interface{}) error {
err := UserDB.Where("user_id=?", user.UserID).Updates(m).Error
return err
}
func SelectAllUserID() ([]string, error) {
var resultArr []string
err := UserDB.Pluck("user_id", &resultArr).Error
if err != nil {
return nil, err
}
return resultArr, nil
}
func SelectSomeUserID(userIDList []string) ([]string, error) {
var resultArr []string
err := UserDB.Pluck("user_id", &resultArr).Error
if err != nil {
return nil, err
}
return resultArr, nil
}
func GetUsers(showNumber, pageNumber int32) ([]User, error) {
var users []User
err := UserDB.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
if err != nil {
return users, err
}
return users, err
}
func AddUser(userID string, phoneNumber string, name string, email string, gender int32, faceURL string, birth string) error {
_birth, err := utils.TimeStringToTime(birth)
if err != nil {
return err
}
user := User{
UserID: userID,
Nickname: name,
FaceURL: faceURL,
Gender: gender,
PhoneNumber: phoneNumber,
Birth: _birth,
Email: email,
Ex: "",
CreateTime: time.Now(),
}
result := UserDB.Create(&user)
return result.Error
}
func UsersIsBlock(userIDList []string) (inBlockUserIDList []string, err error) {
err = BlackListDB.Where("uid in (?) and end_disable_time > now()", userIDList).Pluck("uid", &inBlockUserIDList).Error
return inBlockUserIDList, err
}
type BlockUserInfo struct {
User User
BeginDisableTime time.Time
EndDisableTime time.Time
}
func GetUserByName(userName string, showNumber, pageNumber int32) ([]User, error) {
var users []User
err := UserDB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
return users, err
}
func GetUsersByNameAndID(content string, showNumber, pageNumber int32) ([]User, int64, error) {
var users []User
var count int64
db := UserDB.Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content)
if err := db.Count(&count).Error; err != nil {
return nil, 0, err
}
err := db.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
return users, count, err
}
func GetUserIDsByEmailAndID(phoneNumber, email string) ([]string, error) {
if phoneNumber == "" && email == "" {
return nil, nil
}
db := UserDB
if phoneNumber != "" {
db = db.Where("phone_number = ? ", phoneNumber)
}
if email != "" {
db = db.Where("email = ? ", email)
}
var userIDList []string
err := db.Pluck("user_id", &userIDList).Error
return userIDList, err
}
func GetUsersCount(userName string) (int32, error) {
var count int64
if err := UserDB.Where(" name like ? ", fmt.Sprintf("%%%s%%", userName)).Count(&count).Error; err != nil {
return 0, err
}
return int32(count), nil
}
func GetBlockUsersNumCount() (int32, error) {
var count int64
if err := BlackListDB.Count(&count).Error; err != nil {
return 0, err
}
return int32(count), nil
}
pkg/common/db/mysql/user_model_k.go
+66
View File
@@ -0,0 +1,66 @@
package mysql
import (
"Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
var userDB *gorm.DB
type User struct {
UserID string `gorm:"column:user_id;primary_key;size:64"`
Nickname string `gorm:"column:name;size:255"`
FaceURL string `gorm:"column:face_url;size:255"`
Gender int32 `gorm:"column:gender"`
PhoneNumber string `gorm:"column:phone_number;size:32"`
Birth time.Time `gorm:"column:birth"`
Email string `gorm:"column:email;size:64"`
Ex string `gorm:"column:ex;size:1024"`
CreateTime time.Time `gorm:"column:create_time;index:create_time"`
AppMangerLevel int32 `gorm:"column:app_manger_level"`
GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"`
status int32 `gorm:"column:status"`
}
func (*User) Create(ctx context.Context, users []*User) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}()
err = utils.Wrap(userDB.Create(&users).Error, "")
return err
}
func (*User) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args)
}()
return utils.Wrap(userDB.Where("user_id = ?", userID).Updates(args).Error, "")
}
func (*User) Update(ctx context.Context, users []*User) (err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}()
return utils.Wrap(userDB.Updates(&users).Error, "")
}
func (*User) Find(ctx context.Context, userIDs []string) (users []*User, err error) {
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users)
}()
err = utils.Wrap(userDB.Where("user_id in (?)", userIDs).Find(&users).Error, "")
return users, err
}
func (*User) Take(ctx context.Context, userID string) (user *User, err error) {
user = &User{}
defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user)
}()
err = utils.Wrap(userDB.Where("user_id = ?", userID).Take(&user).Error, "")
return user, err
}