msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

fix Pb2String

Browse Source
test-errcode
wangchuxiao 3 years ago
parent 46c3b5a6ea
commit c96ccfc7f5
35 changed files with 720 additions and 726 deletions
Show Stats Download Patch File Download Diff File

1
internal/api_to_rpc/api.go
Unescape View File

@ -1,7 +1,6 @@
package common package common
import ( import (
"Open_IM/internal/fault_tolerant"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
utils2 "Open_IM/pkg/utils" utils2 "Open_IM/pkg/utils"

284
internal/rpc/group/group.go
Unescape View File

@ -13,8 +13,8 @@ import (
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
cp "Open_IM/pkg/common/utils" cp "Open_IM/pkg/common/utils"
"Open_IM/pkg/getcdv3"
open_im_sdk "Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"github.com/OpenIMSDK/getcdv3"
"google.golang.org/grpc/codes" "google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata" "google.golang.org/grpc/metadata"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
@ -567,21 +567,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (resp *pbGroup.GetGroupAllMemberResp, err error) { func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (resp *pbGroup.GetGroupAllMemberResp, err error) {
resp = &pbGroup.GetGroupAllMemberResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.GetGroupAllMemberResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String())
trace_log.ShowLog(ctx)
}()
groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID) groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
memberList, err := rocksCache.GetGroupMembersInfoFromCache(ctx, req.Count, req.Offset, req.GroupID) memberList, err := rocksCache.GetGroupMembersInfoFromCache(ctx, req.Count, req.Offset, req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
for _, v := range memberList { for _, v := range memberList {
var node open_im_sdk.GroupMemberFullInfo var node open_im_sdk.GroupMemberFullInfo
@ -589,7 +582,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
resp.MemberList = append(resp.MemberList, &node) resp.MemberList = append(resp.MemberList, &node)
} }
} }
return return resp, nil
} }
func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (resp *pbGroup.GetGroupMemberListResp, err error) { func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (resp *pbGroup.GetGroupMemberListResp, err error) {
@ -723,7 +716,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
c.GroupID = req.GroupID c.GroupID = req.GroupID
c.IsNotInGroup = true c.IsNotInGroup = true
reqPb.Conversation = &c reqPb.Conversation = &c
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return
@ -774,8 +767,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
for _, userID := range req.MemberList { for _, userID := range req.MemberList {
groupMember, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, userID) groupMember, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, userID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return resp, nil
return
} }
var memberNode open_im_sdk.GroupMemberFullInfo var memberNode open_im_sdk.GroupMemberFullInfo
utils.CopyStructFields(&memberNode, groupMember) utils.CopyStructFields(&memberNode, groupMember)
@ -1027,7 +1019,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
c.IsNotInGroup = false c.IsNotInGroup = false
c.UpdateUnreadCountTime = utils.GetCurrentTimestampByMill() c.UpdateUnreadCountTime = utils.GetCurrentTimestampByMill()
reqPb.Conversation = &c reqPb.Conversation = &c
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return
@ -1167,8 +1159,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
m := make(map[string]interface{}) m := make(map[string]interface{})
m["need_verification"] = req.GroupInfoForSet.NeedVerification.Value m["need_verification"] = req.GroupInfoForSet.NeedVerification.Value
if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
} }
if req.GroupInfoForSet.LookMemberInfo != nil { if req.GroupInfoForSet.LookMemberInfo != nil {
@ -1176,8 +1167,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
m := make(map[string]interface{}) m := make(map[string]interface{})
m["look_member_info"] = req.GroupInfoForSet.LookMemberInfo.Value m["look_member_info"] = req.GroupInfoForSet.LookMemberInfo.Value
if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
} }
if req.GroupInfoForSet.ApplyMemberFriend != nil { if req.GroupInfoForSet.ApplyMemberFriend != nil {
@ -1185,8 +1175,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
m := make(map[string]interface{}) m := make(map[string]interface{})
m["apply_member_friend"] = req.GroupInfoForSet.ApplyMemberFriend.Value m["apply_member_friend"] = req.GroupInfoForSet.ApplyMemberFriend.Value
if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil { if err := imdb.UpdateGroupInfoDefaultZero(req.GroupInfoForSet.GroupID, m); err != nil {
constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) return nil, err
return
} }
} }
//only administrators can set group information //only administrators can set group information
@ -1197,13 +1186,11 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
groupInfo.NotificationUpdateTime = time.Now() groupInfo.NotificationUpdateTime = time.Now()
} }
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupInfoForSet.GroupID); err != nil { if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupInfoForSet.GroupID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err = imdb.SetGroupInfo(groupInfo) err = imdb.SetGroupInfo(groupInfo)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if changedType != 0 { if changedType != 0 {
chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification) chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification)
@ -1211,10 +1198,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
if req.GroupInfoForSet.Notification != "" { if req.GroupInfoForSet.Notification != "" {
//get group member user id //get group member user id
getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: req.OperationID, GroupID: req.GroupInfoForSet.GroupID} getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: req.OperationID, GroupID: req.GroupInfoForSet.GroupID}
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return+
} }
client := pbCache.NewCacheClient(etcdConn) client := pbCache.NewCacheClient(etcdConn)
cacheResp, err := client.GetGroupMemberIDListFromCache(ctx, getGroupMemberIDListFromCacheReq) cacheResp, err := client.GetGroupMemberIDListFromCache(ctx, getGroupMemberIDListFromCacheReq)
@ -1238,7 +1225,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
conversationReq.FieldType = constant.FieldGroupAtType conversationReq.FieldType = constant.FieldGroupAtType
conversation.GroupAtType = constant.GroupNotification conversation.GroupAtType = constant.GroupNotification
conversationReq.UserIDList = cacheResp.UserIDList conversationReq.UserIDList = cacheResp.UserIDList
nEtcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName) nEtcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return
@ -1269,31 +1256,26 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
} }
if req.OldOwnerUserID == req.NewOwnerUserID { if req.OldOwnerUserID == req.NewOwnerUserID {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.NewOwnerUserID) err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.NewOwnerUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.OldOwnerUserID) err = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.OldOwnerUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers} groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
err = imdb.UpdateGroupMemberInfo(groupMemberInfo) err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMemberInfo = imdb.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner} groupMemberInfo = imdb.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
err = imdb.UpdateGroupMemberInfo(groupMemberInfo) err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupOwnerTransferredNotification(req) chat.GroupOwnerTransferredNotification(req)
return return
@ -1305,32 +1287,24 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
Groups: []*pbGroup.CMSGroup{}, Groups: []*pbGroup.CMSGroup{},
Pagination: &open_im_sdk.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber}, Pagination: &open_im_sdk.ResponsePagination{CurrentPage: req.Pagination.PageNumber, ShowNumber: req.Pagination.ShowNumber},
} }
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
if req.GroupID != "" { if req.GroupID != "" {
groupInfoDB, err := imdb.GetGroupInfoByGroupID(req.GroupID) groupInfoDB, err := imdb.GetGroupInfoByGroupID(req.GroupID)
if err != nil { if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) { if errors.Is(err, gorm.ErrRecordNotFound) {
return resp, nil return resp, nil
} }
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
resp.GroupNum = 1 resp.GroupNum = 1
groupInfo := &open_im_sdk.GroupInfo{} groupInfo := &open_im_sdk.GroupInfo{}
utils.CopyStructFields(groupInfo, groupInfoDB) utils.CopyStructFields(groupInfo, groupInfoDB)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(req.GroupID) groupMember, err := imdb.GetGroupOwnerInfoByGroupID(req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
memberNum, err := imdb.GetGroupMembersCount(req.GroupID, "") memberNum, err := imdb.GetGroupMembersCount(req.GroupID, "")
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupInfo.MemberCount = uint32(memberNum) groupInfo.MemberCount = uint32(memberNum)
groupInfo.CreateTime = uint32(groupInfoDB.CreateTime.Unix()) groupInfo.CreateTime = uint32(groupInfoDB.CreateTime.Unix())
@ -1355,25 +1329,18 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
} }
resp.GroupNum = int32(count) resp.GroupNum = int32(count)
} }
return return resp, nil
} }
func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (resp *pbGroup.GetGroupMembersCMSResp, _ error) { func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGroupMembersCMSReq) (resp *pbGroup.GetGroupMembersCMSResp, _ error) {
resp = &pbGroup.GetGroupMembersCMSResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.GetGroupMembersCMSResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupID, req.UserName) groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupID, req.UserName)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
log.NewInfo(req.OperationID, groupMembersCount) log.NewInfo(req.OperationID, groupMembersCount)
resp.MemberNums = int32(groupMembersCount) resp.MemberNums = int32(groupMembersCount)
@ -1388,20 +1355,14 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
CurrentPage: req.Pagination.PageNumber, CurrentPage: req.Pagination.PageNumber,
ShowNumber: req.Pagination.ShowNumber, ShowNumber: req.Pagination.ShowNumber,
} }
return return resp, nil
} }
func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (resp *pbGroup.GetUserReqApplicationListResp, _ error) { func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGroup.GetUserReqApplicationListReq) (resp *pbGroup.GetUserReqApplicationListResp, _ error) {
resp = &pbGroup.GetUserReqApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.GetUserReqApplicationListResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
groupRequests, err := imdb.GetUserReqGroupByUserID(req.UserID) groupRequests, err := imdb.GetUserReqGroupByUserID(req.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
for _, groupReq := range groupRequests { for _, groupReq := range groupRequests {
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}} node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
@ -1420,39 +1381,29 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
cp.GroupDBCopyOpenIM(node.GroupInfo, group) cp.GroupDBCopyOpenIM(node.GroupInfo, group)
resp.GroupRequestList = append(resp.GroupRequestList, &node) resp.GroupRequestList = append(resp.GroupRequestList, &node)
} }
return return resp, nil
} }
func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (resp *pbGroup.DismissGroupResp, _ error) { func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (resp *pbGroup.DismissGroupResp, err error) {
resp = &pbGroup.DismissGroupResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.DismissGroupResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) { if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) return nil, utils.Wrap(constant.ErrNoPermission, "")
return
} }
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if err := s.DelGroupAndUserCache(ctx, req.GroupID, nil); err != nil { if err := s.DelGroupAndUserCache(ctx, req.GroupID, nil); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err := imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusDismissed) err = imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusDismissed)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID) groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID) memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID)
@ -1470,28 +1421,26 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
c.GroupID = req.GroupID c.GroupID = req.GroupID
c.IsNotInGroup = true c.IsNotInGroup = true
reqPb.Conversation = &c reqPb.Conversation = &c
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) respPb, err := client.SetConversation(context.Background(), &reqPb)
trace_log.SetContextInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) trace_log.SetContextInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
} }
err = imdb.DeleteGroupMemberByGroupID(req.GroupID) err = imdb.DeleteGroupMemberByGroupID(req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupDismissedNotification(req) chat.GroupDismissedNotification(req)
} else { } else {
err = db.DB.DeleteSuperGroup(req.GroupID) err = db.DB.DeleteSuperGroup(req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
} }
return return resp, nil
} }
func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (resp *pbGroup.MuteGroupMemberResp, _ error) { func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (resp *pbGroup.MuteGroupMemberResp, err error) {
resp = &pbGroup.MuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.MuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() { defer func() {
@ -1500,108 +1449,79 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
}() }()
opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if opFlag == 0 { if opFlag == 0 {
constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) return nil, utils.Wrap(constant.ErrNoPermission, "")
return
} }
mutedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID) mutedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return nil, err
} }
if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID} groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano()) groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano())
err = imdb.UpdateGroupMemberInfo(groupMemberInfo) err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupMemberMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, req.MutedSeconds) chat.GroupMemberMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, req.MutedSeconds)
return return resp, nil
} }
func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (resp *pbGroup.CancelMuteGroupMemberResp, _ error) { func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (resp *pbGroup.CancelMuteGroupMemberResp, err error) {
resp = &pbGroup.CancelMuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.CancelMuteGroupMemberResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if opFlag == 0 { if opFlag == 0 {
constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp) return nil, utils.Wrap(constant.ErrNoPermission, "")
return
} }
mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID) mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { if mutedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { if mutedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID} groupMemberInfo := imdb.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo.MuteEndTime = time.Unix(0, 0) groupMemberInfo.MuteEndTime = time.Unix(0, 0)
err = imdb.UpdateGroupMemberInfo(groupMemberInfo) err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupMemberCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) chat.GroupMemberCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
return return resp, nil
} }
func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (resp *pbGroup.MuteGroupResp, _ error) { func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (resp *pbGroup.MuteGroupResp, err error) {
resp = &pbGroup.MuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.MuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return
} }
if opFlag == 0 { if opFlag == 0 {
//errMsg := req.OperationID + "opFlag == 0 " + req.GroupID + req.OpUserID return nil, utils.Wrap(constant.ErrNoPermission, "")
//log.Error(req.OperationID, errMsg)
//return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
constant.SetErrorForResp(constant.ErrNoPermission, resp.CommonResp)
return
} }
//mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID) //mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.UserID)
@ -1618,35 +1538,28 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
// return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil // return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
//} //}
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err = imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusMuted) err = imdb.OperateGroupStatus(req.GroupID, constant.GroupStatusMuted)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupMutedNotification(req.OperationID, req.OpUserID, req.GroupID) chat.GroupMutedNotification(req.OperationID, req.OpUserID, req.GroupID)
return return resp, nil
} }
func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (resp *pbGroup.CancelMuteGroupResp, _ error) { func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (resp *pbGroup.CancelMuteGroupResp, err error) {
resp = &pbGroup.CancelMuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.CancelMuteGroupResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID) opFlag, err := s.getGroupUserLevel(req.GroupID, req.OpUserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return nil, err
} }
if opFlag == 0 { if opFlag == 0 {
constant.SetErrorForResp(err, resp.CommonResp) constant.SetErrorForResp(err, resp.CommonResp)
return return nil, err
} }
//mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.) //mutedInfo, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(req.GroupID, req.)
//if err != nil { //if err != nil {
@ -1663,28 +1576,20 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
//} //}
log.Debug(req.OperationID, "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk}) log.Debug(req.OperationID, "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk})
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil { if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
err = imdb.UpdateGroupInfoDefaultZero(req.GroupID, map[string]interface{}{"status": constant.GroupOk}) err = imdb.UpdateGroupInfoDefaultZero(req.GroupID, map[string]interface{}{"status": constant.GroupOk})
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID) chat.GroupCancelMutedNotification(req.OperationID, req.OpUserID, req.GroupID)
return return resp, nil
} }
func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (resp *pbGroup.SetGroupMemberNicknameResp, _ error) { func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (resp *pbGroup.SetGroupMemberNicknameResp, err error) {
resp = &pbGroup.SetGroupMemberNicknameResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.SetGroupMemberNicknameResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) { if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) {
constant.SetErrorForResp(constant.ErrIdentity, resp.CommonResp) return nil, utils.Wrap(constant.ErrNoPermission, "")
return
} }
cbReq := &pbGroup.SetGroupMemberInfoReq{ cbReq := &pbGroup.SetGroupMemberInfoReq{
GroupID: req.GroupID, GroupID: req.GroupID,
@ -1694,8 +1599,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
Nickname: &wrapperspb.StringValue{Value: req.Nickname}, Nickname: &wrapperspb.StringValue{Value: req.Nickname},
} }
if err := CallbackBeforeSetGroupMemberInfo(ctx, cbReq); err != nil { if err := CallbackBeforeSetGroupMemberInfo(ctx, cbReq); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
nickName := cbReq.Nickname.Value nickName := cbReq.Nickname.Value
groupMemberInfo := imdb.GroupMember{} groupMemberInfo := imdb.GroupMember{}
@ -1704,8 +1608,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
if nickName == "" { if nickName == "" {
userNickname, err := imdb.GetUserNameByUserID(groupMemberInfo.UserID) userNickname, err := imdb.GetUserNameByUserID(groupMemberInfo.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMemberInfo.Nickname = userNickname groupMemberInfo.Nickname = userNickname
} else { } else {
@ -1713,32 +1616,23 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
} }
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if err := imdb.UpdateGroupMemberInfo(groupMemberInfo); err != nil { if err := imdb.UpdateGroupMemberInfo(groupMemberInfo); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
return return resp, nil
} }
func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (resp *pbGroup.SetGroupMemberInfoResp, _ error) { func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (resp *pbGroup.SetGroupMemberInfoResp, err error) {
resp = &pbGroup.SetGroupMemberInfoResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.SetGroupMemberInfoResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil { if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil { if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
groupMember := imdb.GroupMember{ groupMember := imdb.GroupMember{
GroupID: req.GroupID, GroupID: req.GroupID,
@ -1760,8 +1654,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
m["ex"] = nil m["ex"] = nil
} }
if err := imdb.UpdateGroupMemberInfoByMap(groupMember, m); err != nil { if err := imdb.UpdateGroupMemberInfoByMap(groupMember, m); err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
if req.RoleLevel != nil { if req.RoleLevel != nil {
switch req.RoleLevel.Value { switch req.RoleLevel.Value {
@ -1775,26 +1668,19 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
} else { } else {
chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID) chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
} }
return return resp, nil
} }
func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (resp *pbGroup.GetGroupAbstractInfoResp, _ error) { func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (resp *pbGroup.GetGroupAbstractInfoResp, err error) {
resp = &pbGroup.GetGroupAbstractInfoResp{CommonResp: &open_im_sdk.CommonResp{}} resp = &pbGroup.GetGroupAbstractInfoResp{CommonResp: &open_im_sdk.CommonResp{}}
ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID)
defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), nil, "rpc req ", req.String(), "rpc resp ", resp.String())
trace_log.ShowLog(ctx)
}()
hashCode, err := rocksCache.GetGroupMemberListHashFromCache(ctx, req.GroupID) hashCode, err := rocksCache.GetGroupMemberListHashFromCache(ctx, req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
resp.GroupMemberListHash = hashCode resp.GroupMemberListHash = hashCode
num, err := rocksCache.GetGroupMemberNumFromCache(ctx, req.GroupID) num, err := rocksCache.GetGroupMemberNumFromCache(ctx, req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return nil, err
return
} }
resp.GroupMemberNumber = int32(num) resp.GroupMemberNumber = int32(num)
return resp, nil return resp, nil
@ -1803,7 +1689,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error { func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error {
operationID := trace_log.GetOperationID(ctx) operationID := trace_log.GetOperationID(ctx)
if groupID != "" { if groupID != "" {
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {
return err return err
} }

14
internal/rpc/group/super_group.go
Unescape View File

@ -14,8 +14,8 @@ import (
func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.GetJoinedSuperGroupListReq) (*pbGroup.GetJoinedSuperGroupListResp, error) { func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.GetJoinedSuperGroupListReq) (*pbGroup.GetJoinedSuperGroupListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbGroup.GetJoinedSuperGroupListResp{CommonResp: &pbGroup.CommonResp{}} resp := &pbGroup.GetJoinedSuperGroupListResp{CommonResp: &commonPb.CommonResp{}}
groupIDList, err := rocksCache.GetJoinedSuperGroupListFromCache(req.UserID) groupIDList, err := rocksCache.GetJoinedSuperGroupListFromCache(ctx, req.UserID)
if err != nil { if err != nil {
if err == redis.Nil { if err == redis.Nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroupByUserID nil ", err.Error(), req.UserID) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroupByUserID nil ", err.Error(), req.UserID)
@ -27,7 +27,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return resp, nil return resp, nil
} }
for _, groupID := range groupIDList { for _, groupID := range groupIDList {
groupInfoFromCache, err := rocksCache.GetGroupInfoFromCache(groupID) groupInfoFromCache, err := rocksCache.GetGroupInfoFromCache(ctx, groupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupInfoByGroupID failed", groupID, err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupInfoByGroupID failed", groupID, err.Error())
continue continue
@ -36,7 +36,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
if err := utils.CopyStructFields(groupInfo, groupInfoFromCache); err != nil { if err := utils.CopyStructFields(groupInfo, groupInfoFromCache); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
} }
groupMemberIDList, err := rocksCache.GetGroupMemberIDListFromCache(groupID) groupMemberIDList, err := rocksCache.GetGroupMemberIDListFromCache(ctx, groupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroup failed", groupID, err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetSuperGroup failed", groupID, err.Error())
continue continue
@ -48,12 +48,12 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return resp, nil return resp, nil
} }
func (s *groupServer) GetSuperGroupsInfo(_ context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) { func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp = &pbGroup.GetSuperGroupsInfoResp{CommonResp: &pbGroup.CommonResp{}} resp = &pbGroup.GetSuperGroupsInfoResp{CommonResp: &commonPb.CommonResp{}}
groupsInfoList := make([]*commonPb.GroupInfo, 0) groupsInfoList := make([]*commonPb.GroupInfo, 0)
for _, groupID := range req.GroupIDList { for _, groupID := range req.GroupIDList {
groupInfoFromRedis, err := rocksCache.GetGroupInfoFromCache(groupID) groupInfoFromRedis, err := rocksCache.GetGroupInfoFromCache(ctx, groupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID) log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), groupID)
continue continue

15
internal/rpc/msg/callback.go
Unescape View File

@ -51,7 +51,8 @@ func callbackBeforeSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackRes
} }
//utils.CopyStructFields(req, msg.MsgData) //utils.CopyStructFields(req, msg.MsgData)
defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendSingleMsgCommand, req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendSingleMsgCommand,
req, resp, config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue { if !config.Config.Callback.CallbackBeforeSendSingleMsg.CallbackFailedContinue {
@ -79,7 +80,8 @@ func callbackAfterSendSingleMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp
} }
resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackAfterSendSingleMsgResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendSingleMsgCommand, req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendSingleMsgCommand,
req, resp, config.Config.Callback.CallbackAfterSendSingleMsg.CallbackTimeOut, &config.Config.Callback.CallbackAfterSendSingleMsg.CallbackFailedContinue); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
return callbackResp return callbackResp
@ -101,7 +103,8 @@ func callbackBeforeSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp
} }
resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackBeforeSendGroupMsgResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendGroupMsgCommand, req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSendGroupMsgCommand,
req, resp, config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackTimeOut, &config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue { if !config.Config.Callback.CallbackBeforeSendGroupMsg.CallbackFailedContinue {
@ -129,7 +132,8 @@ func callbackAfterSendGroupMsg(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp
} }
resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackAfterSendGroupMsgResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendGroupMsgCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackAfterSendGroupMsgCommand, req, resp,
config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
return callbackResp return callbackResp
@ -150,7 +154,8 @@ func callbackMsgModify(msg *pbChat.SendMsgReq) cbApi.CommonCallbackResp {
} }
resp := &cbApi.CallbackMsgModifyCommandResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackMsgModifyCommandResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(msg.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackMsgModifyCommand, req, resp, config.Config.Callback.CallbackMsgModify.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackMsgModifyCommand, req, resp,
config.Config.Callback.CallbackMsgModify.CallbackTimeOut, &config.Config.Callback.CallbackMsgModify.CallbackFailedContinue); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
if !config.Config.Callback.CallbackMsgModify.CallbackFailedContinue { if !config.Config.Callback.CallbackMsgModify.CallbackFailedContinue {

12
internal/rpc/msg/chat.go
Unescape View File

@ -15,21 +15,21 @@ func (rpc *rpcChat) ClearMsg(_ context.Context, req *pbChat.ClearMsgReq) (*pbCha
if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) { if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) {
errMsg := "No permission" + req.OpUserID + req.UserID errMsg := "No permission" + req.OpUserID + req.UserID
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.ClearMsgResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil return &pbChat.ClearMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
} }
log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID) log.Debug(req.OperationID, "CleanUpOneUserAllMsgFromRedis args", req.UserID)
err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID) err := db.DB.CleanUpOneUserAllMsgFromRedis(req.UserID, req.OperationID)
if err != nil { if err != nil {
errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID errMsg := "CleanUpOneUserAllMsgFromRedis failed " + err.Error() + req.OperationID + req.UserID
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
} }
log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID) log.Debug(req.OperationID, "CleanUpUserMsgFromMongo args", req.UserID)
err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID) err = db.DB.CleanUpUserMsgFromMongo(req.UserID, req.OperationID)
if err != nil { if err != nil {
errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID errMsg := "CleanUpUserMsgFromMongo failed " + err.Error() + req.OperationID + req.UserID
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.ClearMsgResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil return &pbChat.ClearMsgResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
} }
resp := pbChat.ClearMsgResp{ErrCode: 0} resp := pbChat.ClearMsgResp{ErrCode: 0}
@ -42,14 +42,14 @@ func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq)
if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) { if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.UserID) {
errMsg := "No permission" + req.OpUserID + req.UserID errMsg := "No permission" + req.OpUserID + req.UserID
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: errMsg}, nil
} }
if req.GroupID == "" { if req.GroupID == "" {
err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq) err := db.DB.SetUserMinSeq(req.UserID, req.MinSeq)
if err != nil { if err != nil {
errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq) errMsg := "SetUserMinSeq failed " + err.Error() + req.OperationID + req.UserID + utils.Uint32ToString(req.MinSeq)
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
} }
return &pbChat.SetMsgMinSeqResp{}, nil return &pbChat.SetMsgMinSeqResp{}, nil
} }
@ -57,7 +57,7 @@ func (rpc *rpcChat) SetMsgMinSeq(_ context.Context, req *pbChat.SetMsgMinSeqReq)
if err != nil { if err != nil {
errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq) errMsg := "SetGroupUserMinSeq failed " + err.Error() + req.OperationID + req.GroupID + req.UserID + utils.Uint32ToString(req.MinSeq)
log.Error(req.OperationID, errMsg) log.Error(req.OperationID, errMsg)
return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil return &pbChat.SetMsgMinSeqResp{ErrCode: constant.ErrDatabase.ErrCode, ErrMsg: errMsg}, nil
} }
return &pbChat.SetMsgMinSeqResp{}, nil return &pbChat.SetMsgMinSeqResp{}, nil
} }

14
internal/rpc/msg/del_msg.go
Unescape View File

@ -5,8 +5,8 @@ import (
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
commonPb "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/proto/msg" "Open_IM/pkg/proto/msg"
commonPb "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"time" "time"
@ -30,23 +30,23 @@ func (rpc *rpcChat) DelMsgList(_ context.Context, req *commonPb.DelMsgListReq) (
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil return resp, nil
} }
func (rpc *rpcChat) DelSuperGroupMsg(_ context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) { func (rpc *rpcChat) DelSuperGroupMsg(ctx context.Context, req *msg.DelSuperGroupMsgReq) (*msg.DelSuperGroupMsgResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
if !token_verify.CheckAccess(req.OpUserID, req.UserID) { if !token_verify.CheckAccess(ctx, req.OpUserID, req.UserID) {
log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserID) log.NewError(req.OperationID, "CheckAccess false ", req.OpUserID, req.UserID)
return &msg.DelSuperGroupMsgResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &msg.DelSuperGroupMsgResp{ErrCode: constant.ErrNoPermission.ErrCode, ErrMsg: constant.ErrNoPermission.ErrMsg}, nil
} }
resp := &msg.DelSuperGroupMsgResp{} resp := &msg.DelSuperGroupMsgResp{}
groupMaxSeq, err := db.DB.GetGroupMaxSeq(req.GroupID) groupMaxSeq, err := db.DB.GetGroupMaxSeq(req.GroupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, "GetGroupMaxSeq false ", req.OpUserID, req.UserID,req.GroupID) log.NewError(req.OperationID, "GetGroupMaxSeq false ", req.OpUserID, req.UserID, req.GroupID)
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = err.Error() resp.ErrMsg = err.Error()
return resp, nil return resp, nil
} }
err = db.DB.SetGroupUserMinSeq(req.GroupID,req.UserID, groupMaxSeq) err = db.DB.SetGroupUserMinSeq(req.GroupID, req.UserID, groupMaxSeq)
if err != nil { if err != nil {
log.NewError(req.OperationID, "SetGroupUserMinSeq false ", req.OpUserID, req.UserID,req.GroupID) log.NewError(req.OperationID, "SetGroupUserMinSeq false ", req.OpUserID, req.UserID, req.GroupID)
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDB.ErrCode
resp.ErrMsg = err.Error() resp.ErrMsg = err.Error()
return resp, nil return resp, nil

3
internal/rpc/msg/extend_msg.notification.go
Unescape View File

@ -5,6 +5,7 @@ import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/getcdv3"
"Open_IM/pkg/proto/msg" "Open_IM/pkg/proto/msg"
open_im_sdk "Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
@ -87,7 +88,7 @@ func messageReactionSender(operationID, sendID string, sourceID string, sessionT
case constant.GroupChatType, constant.SuperGroupChatType: case constant.GroupChatType, constant.SuperGroupChatType:
pbData.MsgData.GroupID = sourceID pbData.MsgData.GroupID = sourceID
} }
etcdConn, err := utils.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName) etcdConn, err := getcdv3.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImMsgName)
if err != nil { if err != nil {
return return
} }

6
internal/rpc/msg/extend_msg_callback.go
Unescape View File

@ -28,7 +28,8 @@ func callbackSetMessageReactionExtensions(setReq *msg.SetMessageReactionExtensio
} }
resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackBeforeSetMessageReactionExtResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeSetMessageReactionExtensionCommand,
req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
} }
@ -52,7 +53,8 @@ func callbackDeleteMessageReactionExtensions(setReq *msg.DeleteMessageListReacti
} }
resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp} resp := &cbApi.CallbackDeleteMessageReactionExtResp{CommonCallbackResp: &callbackResp}
defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp) defer log.NewDebug(setReq.OperationID, utils.GetSelfFuncName(), req, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand, req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut); err != nil { if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeDeleteMessageReactionExtensionsCommand,
req, resp, config.Config.Callback.CallbackAfterSendGroupMsg.CallbackTimeOut, nil); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error() callbackResp.ErrMsg = err.Error()
} }

2
internal/rpc/msg/msg_status.go
Unescape View File

@ -16,7 +16,7 @@ func (rpc *rpcChat) SetSendMsgStatus(_ context.Context, req *pbMsg.SetSendMsgSta
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
if err := db.DB.SetSendMsgStatus(req.Status, req.OperationID); err != nil { if err := db.DB.SetSendMsgStatus(req.Status, req.OperationID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
resp.ErrCode = constant.ErrDB.ErrCode resp.ErrCode = constant.ErrDatabase.ErrCode
resp.ErrMsg = err.Error() resp.ErrMsg = err.Error()
return resp, nil return resp, nil
} }

27
internal/rpc/msg/send_msg.go
Unescape View File

@ -8,6 +8,7 @@ import (
rocksCache "Open_IM/pkg/common/db/rocks_cache" rocksCache "Open_IM/pkg/common/db/rocks_cache"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/getcdv3"
cacheRpc "Open_IM/pkg/proto/cache" cacheRpc "Open_IM/pkg/proto/cache"
pbConversation "Open_IM/pkg/proto/conversation" pbConversation "Open_IM/pkg/proto/conversation"
pbChat "Open_IM/pkg/proto/msg" pbChat "Open_IM/pkg/proto/msg"
@ -129,7 +130,7 @@ func (rpc *rpcChat) messageVerification(ctx context.Context, data *pbChat.SendMs
} }
log.NewDebug(data.OperationID, *config.Config.MessageVerify.FriendVerify) log.NewDebug(data.OperationID, *config.Config.MessageVerify.FriendVerify)
reqGetBlackIDListFromCache := &cacheRpc.GetBlackIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID} reqGetBlackIDListFromCache := &cacheRpc.GetBlackIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
etcdConn, err := utils.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {
errMsg := data.OperationID + "getcdv3.GetDefaultConn == nil" errMsg := data.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(data.OperationID, errMsg) log.NewError(data.OperationID, errMsg)
@ -152,7 +153,7 @@ func (rpc *rpcChat) messageVerification(ctx context.Context, data *pbChat.SendMs
log.NewDebug(data.OperationID, *config.Config.MessageVerify.FriendVerify) log.NewDebug(data.OperationID, *config.Config.MessageVerify.FriendVerify)
if *config.Config.MessageVerify.FriendVerify { if *config.Config.MessageVerify.FriendVerify {
reqGetFriendIDListFromCache := &cacheRpc.GetFriendIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID} reqGetFriendIDListFromCache := &cacheRpc.GetFriendIDListFromCacheReq{UserID: data.MsgData.RecvID, OperationID: data.OperationID}
etcdConn, err := utils.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {
errMsg := data.OperationID + "getcdv3.GetDefaultConn == nil" errMsg := data.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(data.OperationID, errMsg) log.NewError(data.OperationID, errMsg)
@ -176,7 +177,7 @@ func (rpc *rpcChat) messageVerification(ctx context.Context, data *pbChat.SendMs
return true, 0, "", nil return true, 0, "", nil
} }
case constant.GroupChatType: case constant.GroupChatType:
userIDList, err := utils2.GetGroupMemberUserIDList(data.MsgData.GroupID, data.OperationID) userIDList, err := utils2.GetGroupMemberUserIDList(ctx, data.MsgData.GroupID, data.OperationID)
if err != nil { if err != nil {
errMsg := data.OperationID + err.Error() errMsg := data.OperationID + err.Error()
log.NewError(data.OperationID, errMsg) log.NewError(data.OperationID, errMsg)
@ -250,7 +251,7 @@ func (rpc *rpcChat) messageVerification(ctx context.Context, data *pbChat.SendMs
if groupInfo.GroupType == constant.SuperGroup { if groupInfo.GroupType == constant.SuperGroup {
return true, 0, "", nil return true, 0, "", nil
} else { } else {
userIDList, err := utils2.GetGroupMemberUserIDList(data.MsgData.GroupID, data.OperationID) userIDList, err := utils2.GetGroupMemberUserIDList(ctx, data.MsgData.GroupID, data.OperationID)
if err != nil { if err != nil {
errMsg := data.OperationID + err.Error() errMsg := data.OperationID + err.Error()
log.NewError(data.OperationID, errMsg) log.NewError(data.OperationID, errMsg)
@ -485,13 +486,13 @@ func (rpc *rpcChat) SendMsg(ctx context.Context, pb *pbChat.SendMsgReq) (*pbChat
wg.Add(1) wg.Add(1)
tmp := valueCopy(pb) tmp := valueCopy(pb)
// go rpc.sendMsgToGroup(v[i*split:(i+1)*split], *pb, k, &sendTag, &wg) // go rpc.sendMsgToGroup(v[i*split:(i+1)*split], *pb, k, &sendTag, &wg)
go rpc.sendMsgToGroupOptimization(v[i*split:(i+1)*split], tmp, k, &sendTag, &wg) go rpc.sendMsgToGroupOptimization(ctx, v[i*split:(i+1)*split], tmp, k, &sendTag, &wg)
} }
if remain > 0 { if remain > 0 {
wg.Add(1) wg.Add(1)
tmp := valueCopy(pb) tmp := valueCopy(pb)
// go rpc.sendMsgToGroup(v[split*(len(v)/split):], *pb, k, &sendTag, &wg) // go rpc.sendMsgToGroup(v[split*(len(v)/split):], *pb, k, &sendTag, &wg)
go rpc.sendMsgToGroupOptimization(v[split*(len(v)/split):], tmp, k, &sendTag, &wg) go rpc.sendMsgToGroupOptimization(ctx, v[split*(len(v)/split):], tmp, k, &sendTag, &wg)
} }
} }
log.Debug(pb.OperationID, "send msg cost time22 ", time.Since(t1), pb.MsgData.ClientMsgID, "uidList : ", len(addUidList)) log.Debug(pb.OperationID, "send msg cost time22 ", time.Since(t1), pb.MsgData.ClientMsgID, "uidList : ", len(addUidList))
@ -538,7 +539,7 @@ func (rpc *rpcChat) SendMsg(ctx context.Context, pb *pbChat.SendMsgReq) (*pbChat
conversationReq.UserIDList = pb.MsgData.AtUserIDList conversationReq.UserIDList = pb.MsgData.AtUserIDList
conversation.GroupAtType = constant.AtMe conversation.GroupAtType = constant.AtMe
} }
etcdConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName)
if err != nil { if err != nil {
errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil" errMsg := pb.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(pb.OperationID, errMsg) log.NewError(pb.OperationID, errMsg)
@ -615,7 +616,7 @@ func (rpc *rpcChat) SendMsg(ctx context.Context, pb *pbChat.SendMsgReq) (*pbChat
} }
msgToMQSingle.MsgData = pb.MsgData msgToMQSingle.MsgData = pb.MsgData
log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle) log.NewInfo(msgToMQSingle.OperationID, msgToMQSingle)
err1 := rpc.sendMsgToWriter(&msgToMQSingle, msgToMQSingle.MsgData.GroupID, constant.OnlineStatus) err1 := rpc.sendMsgToWriter(ctx, &msgToMQSingle, msgToMQSingle.MsgData.GroupID, constant.OnlineStatus)
if err1 != nil { if err1 != nil {
log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String()) log.NewError(msgToMQSingle.OperationID, "kafka send msg err:RecvID", msgToMQSingle.MsgData.RecvID, msgToMQSingle.String())
promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter) promePkg.PromeInc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
@ -639,7 +640,7 @@ func (rpc *rpcChat) sendMsgToWriter(ctx context.Context, m *pbChat.MsgDataToMQ,
case constant.OnlineStatus: case constant.OnlineStatus:
if m.MsgData.ContentType == constant.SignalingNotification { if m.MsgData.ContentType == constant.SignalingNotification {
rpcPushMsg := pbPush.PushMsgReq{OperationID: m.OperationID, MsgData: m.MsgData, PushToUserID: key} rpcPushMsg := pbPush.PushMsgReq{OperationID: m.OperationID, MsgData: m.MsgData, PushToUserID: key}
grpcConn, err := utils.GetConn(ctx, config.Config.RpcRegisterName.OpenImPushName) grpcConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImPushName)
if err != nil { if err != nil {
return err return err
} }
@ -1103,7 +1104,7 @@ func valueCopy(pb *pbChat.SendMsgReq) *pbChat.SendMsgReq {
return &pbChat.SendMsgReq{Token: pb.Token, OperationID: pb.OperationID, MsgData: &msgData} return &pbChat.SendMsgReq{Token: pb.Token, OperationID: pb.OperationID, MsgData: &msgData}
} }
func (rpc *rpcChat) sendMsgToGroup(list []string, pb pbChat.SendMsgReq, status string, sendTag *bool, wg *sync.WaitGroup) { func (rpc *rpcChat) sendMsgToGroup(ctx context.Context, list []string, pb pbChat.SendMsgReq, status string, sendTag *bool, wg *sync.WaitGroup) {
// log.Debug(pb.OperationID, "split userID ", list) // log.Debug(pb.OperationID, "split userID ", list)
offlinePushInfo := sdk_ws.OfflinePushInfo{} offlinePushInfo := sdk_ws.OfflinePushInfo{}
if pb.MsgData.OfflinePushInfo != nil { if pb.MsgData.OfflinePushInfo != nil {
@ -1126,7 +1127,7 @@ func (rpc *rpcChat) sendMsgToGroup(list []string, pb pbChat.SendMsgReq, status s
if isSend { if isSend {
msgToMQGroup.MsgData = groupPB.MsgData msgToMQGroup.MsgData = groupPB.MsgData
// log.Debug(groupPB.OperationID, "sendMsgToWriter, ", v, groupID, msgToMQGroup.String()) // log.Debug(groupPB.OperationID, "sendMsgToWriter, ", v, groupID, msgToMQGroup.String())
err := rpc.sendMsgToWriter(&msgToMQGroup, v, status) err := rpc.sendMsgToWriter(ctx, &msgToMQGroup, v, status)
if err != nil { if err != nil {
log.NewError(msgToMQGroup.OperationID, "kafka send msg err:UserId", v, msgToMQGroup.String()) log.NewError(msgToMQGroup.OperationID, "kafka send msg err:UserId", v, msgToMQGroup.String())
} else { } else {
@ -1139,7 +1140,7 @@ func (rpc *rpcChat) sendMsgToGroup(list []string, pb pbChat.SendMsgReq, status s
wg.Done() wg.Done()
} }
func (rpc *rpcChat) sendMsgToGroupOptimization(list []string, groupPB *pbChat.SendMsgReq, status string, sendTag *bool, wg *sync.WaitGroup) { func (rpc *rpcChat) sendMsgToGroupOptimization(ctx context.Context, list []string, groupPB *pbChat.SendMsgReq, status string, sendTag *bool, wg *sync.WaitGroup) {
msgToMQGroup := pbChat.MsgDataToMQ{Token: groupPB.Token, OperationID: groupPB.OperationID, MsgData: groupPB.MsgData} msgToMQGroup := pbChat.MsgDataToMQ{Token: groupPB.Token, OperationID: groupPB.OperationID, MsgData: groupPB.MsgData}
tempOptions := make(map[string]bool, 1) tempOptions := make(map[string]bool, 1)
for k, v := range groupPB.MsgData.Options { for k, v := range groupPB.MsgData.Options {
@ -1158,7 +1159,7 @@ func (rpc *rpcChat) sendMsgToGroupOptimization(list []string, groupPB *pbChat.Se
log.Error(msgToMQGroup.OperationID, "sendMsgToGroupOptimization userID nil ", msgToMQGroup.String()) log.Error(msgToMQGroup.OperationID, "sendMsgToGroupOptimization userID nil ", msgToMQGroup.String())
continue continue
} }
err := rpc.sendMsgToWriter(&msgToMQGroup, v, status) err := rpc.sendMsgToWriter(ctx, &msgToMQGroup, v, status)
if err != nil { if err != nil {
log.NewError(msgToMQGroup.OperationID, "kafka send msg err:UserId", v, msgToMQGroup.String()) log.NewError(msgToMQGroup.OperationID, "kafka send msg err:UserId", v, msgToMQGroup.String())
} else { } else {

3
internal/utils/local_cache.go
Unescape View File

@ -4,6 +4,7 @@ import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
rocksCache "Open_IM/pkg/common/db/rocks_cache" rocksCache "Open_IM/pkg/common/db/rocks_cache"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/getcdv3"
pbCache "Open_IM/pkg/proto/cache" pbCache "Open_IM/pkg/proto/cache"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
@ -59,7 +60,7 @@ func GetGroupMemberUserIDListHashFromRemote(ctx context.Context, groupID string)
func GetGroupMemberUserIDListFromRemote(groupID string, operationID string) ([]string, error) { func GetGroupMemberUserIDListFromRemote(groupID string, operationID string) ([]string, error) {
getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: operationID, GroupID: groupID} getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: operationID, GroupID: groupID}
etcdConn, err := utils.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(context.Background(), config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {
return nil, err return nil, err
} }

5
pkg/common/constant/error.go
Unescape View File

@ -51,6 +51,7 @@ var (
ErrOwnerNotAllowedQuit = ErrInfo{OwnerNotAllowedQuitError, "OwnerNotAllowedQuitError", ""} ErrOwnerNotAllowedQuit = ErrInfo{OwnerNotAllowedQuitError, "OwnerNotAllowedQuitError", ""}
ErrRegisteredAlready = ErrInfo{RegisteredAlreadyError, "RegisteredAlreadyError", ""} ErrRegisteredAlready = ErrInfo{RegisteredAlreadyError, "RegisteredAlreadyError", ""}
ErrGroupTypeNotSupport = ErrInfo{GroupTypeNotSupport, "", ""} ErrGroupTypeNotSupport = ErrInfo{GroupTypeNotSupport, "", ""}
ErrGroupNoOwner = ErrInfo{GroupNoOwner, "ErrGroupNoOwner", ""}
ErrDefaultOther = ErrInfo{DefaultOtherError, "DefaultOtherError", ""} ErrDefaultOther = ErrInfo{DefaultOtherError, "DefaultOtherError", ""}
ErrData = ErrInfo{DataError, "DataError", ""} ErrData = ErrInfo{DataError, "DataError", ""}
@ -65,6 +66,9 @@ var (
ErrTokenDifferentUserID = ErrInfo{TokenDifferentUserIDError, "TokenDifferentUserIDError", ""} ErrTokenDifferentUserID = ErrInfo{TokenDifferentUserIDError, "TokenDifferentUserIDError", ""}
ErrMessageHasReadDisable = ErrInfo{MessageHasReadDisable, "MessageHasReadDisable", ""} ErrMessageHasReadDisable = ErrInfo{MessageHasReadDisable, "MessageHasReadDisable", ""}
ErrDB = ErrDatabase
ErrSendLimit = ErrInternalServer
) )
func NewErrNetwork(err error) error { func NewErrNetwork(err error) error {
@ -185,6 +189,7 @@ const (
DismissedAlreadyError = 93004 //群组已经解散 DismissedAlreadyError = 93004 //群组已经解散
OwnerNotAllowedQuitError = 93004 //群主不能退群 OwnerNotAllowedQuitError = 93004 //群主不能退群
GroupTypeNotSupport = 93005 GroupTypeNotSupport = 93005
GroupNoOwner = 93006
) )
// 用户错误码 // 用户错误码

12
pkg/common/db/mysql_model/im_mysql_model/client_config.go
Unescape View File

@ -1,14 +1,18 @@
package im_mysql_model package im_mysql_model
import "Open_IM/pkg/common/db" import (
"gorm.io/gorm"
)
var InitConfigDB *gorm.DB
func SetClientInitConfig(m map[string]interface{}) error { func SetClientInitConfig(m map[string]interface{}) error {
result := db.DB.MysqlDB.DefaultGormDB().Model(&ClientInitConfig{}).Where("1=1").Updates(m) result := InitConfigDB.Model(&ClientInitConfig{}).Where("1=1").Updates(m)
if result.Error != nil { if result.Error != nil {
return result.Error return result.Error
} }
if result.RowsAffected == 0 { if result.RowsAffected == 0 {
err := db.DB.MysqlDB.DefaultGormDB().Model(&ClientInitConfig{}).Create(m).Error err := InitConfigDB.Model(&ClientInitConfig{}).Create(m).Error
return err return err
} }
@ -17,6 +21,6 @@ func SetClientInitConfig(m map[string]interface{}) error {
func GetClientInitConfig() (ClientInitConfig, error) { func GetClientInitConfig() (ClientInitConfig, error) {
var config ClientInitConfig var config ClientInitConfig
err := db.DB.MysqlDB.DefaultGormDB().Model(&ClientInitConfig{}).First(&config).Error err := InitConfigDB.Model(&ClientInitConfig{}).First(&config).Error
return config, err return config, err
} }

71
pkg/common/db/mysql_model/im_mysql_model/conversation_model.go
Unescape View File

@ -1,42 +1,61 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "gorm.io/gorm"
"Open_IM/pkg/common/log"
"Open_IM/pkg/utils"
) )
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) { func SetConversation(conversation Conversation) (bool, error) {
var isUpdate bool var isUpdate bool
newConversation := conversation newConversation := conversation
if db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 { if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create") return isUpdate, ConversationDB.Model(&Conversation{}).Create(&conversation).Error
return isUpdate, db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record // if exist, then update record
} else { } else {
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
//force update //force update
isUpdate = true isUpdate = true
return isUpdate, db.DB.MysqlDB.DefaultGormDB().Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID). 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, 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 "group_at_type": conversation.GroupAtType, "is_not_in_group": conversation.IsNotInGroup}).Error
} }
} }
func SetOneConversation(conversation Conversation) error { func SetOneConversation(conversation Conversation) error {
return db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Create(&conversation).Error return ConversationDB.Model(&Conversation{}).Create(&conversation).Error
} }
func PeerUserSetConversation(conversation Conversation) error { func PeerUserSetConversation(conversation Conversation) error {
newConversation := conversation newConversation := conversation
if db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 { if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create") return ConversationDB.Model(&Conversation{}).Create(&conversation).Error
return db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record // if exist, then update record
} }
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
//force update //force update
return db.DB.MysqlDB.DefaultGormDB().Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID). 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 Updates(map[string]interface{}{"is_private_chat": conversation.IsPrivateChat}).Error
} }
@ -44,32 +63,30 @@ func PeerUserSetConversation(conversation Conversation) error {
func SetRecvMsgOpt(conversation Conversation) (bool, error) { func SetRecvMsgOpt(conversation Conversation) (bool, error) {
var isUpdate bool var isUpdate bool
newConversation := conversation newConversation := conversation
if db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 { if ConversationDB.Model(&Conversation{}).Find(&newConversation).RowsAffected == 0 {
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "not exist in db, create") return isUpdate, ConversationDB.Model(&Conversation{}).Create(&conversation).Error
return isUpdate, db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Create(&conversation).Error
// if exist, then update record // if exist, then update record
} else { } else {
log.NewDebug("", utils.GetSelfFuncName(), "conversation", conversation, "exist in db, update")
//force update //force update
isUpdate = true isUpdate = true
return isUpdate, db.DB.MysqlDB.DefaultGormDB().Model(conversation).Where("owner_user_id = ? and conversation_id = ?", conversation.OwnerUserID, conversation.ConversationID). 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 Updates(map[string]interface{}{"recv_msg_opt": conversation.RecvMsgOpt}).Error
} }
} }
func GetUserAllConversations(ownerUserID string) ([]Conversation, error) { func GetUserAllConversations(ownerUserID string) ([]Conversation, error) {
var conversations []Conversation var conversations []Conversation
err := db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("owner_user_id=?", ownerUserID).Find(&conversations).Error err := ConversationDB.Where("owner_user_id=?", ownerUserID).Find(&conversations).Error
return conversations, err return conversations, err
} }
func GetMultipleUserConversationByConversationID(ownerUserIDList []string, conversationID string) ([]Conversation, error) { func GetMultipleUserConversationByConversationID(ownerUserIDList []string, conversationID string) ([]Conversation, error) {
var conversations []Conversation var conversations []Conversation
err := db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("owner_user_id IN ? and conversation_id=?", ownerUserIDList, conversationID).Find(&conversations).Error err := ConversationDB.Where("owner_user_id IN ? and conversation_id=?", ownerUserIDList, conversationID).Find(&conversations).Error
return conversations, err return conversations, err
} }
func GetExistConversationUserIDList(ownerUserIDList []string, conversationID string) ([]string, error) { func GetExistConversationUserIDList(ownerUserIDList []string, conversationID string) ([]string, error) {
var resultArr []string var resultArr []string
err := db.DB.MysqlDB.DefaultGormDB().Table("conversations").Where(" owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Pluck("owner_user_id", &resultArr).Error err := ConversationDB.Table("conversations").Where(" owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Pluck("owner_user_id", &resultArr).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -78,29 +95,29 @@ func GetExistConversationUserIDList(ownerUserIDList []string, conversationID str
func GetConversation(OwnerUserID, conversationID string) (Conversation, error) { func GetConversation(OwnerUserID, conversationID string) (Conversation, error) {
var conversation Conversation var conversation Conversation
err := db.DB.MysqlDB.DefaultGormDB().Table("conversations").Where("owner_user_id=? and conversation_id=?", OwnerUserID, conversationID).Take(&conversation).Error err := ConversationDB.Table("conversations").Where("owner_user_id=? and conversation_id=?", OwnerUserID, conversationID).Take(&conversation).Error
return conversation, err return conversation, err
} }
func GetConversations(OwnerUserID string, conversationIDs []string) ([]Conversation, error) { func GetConversations(OwnerUserID string, conversationIDs []string) ([]Conversation, error) {
var conversations []Conversation var conversations []Conversation
err := db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("conversation_id IN (?) and owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error err := ConversationDB.Model(&Conversation{}).Where("conversation_id IN (?) and owner_user_id=?", conversationIDs, OwnerUserID).Find(&conversations).Error
return conversations, err return conversations, err
} }
func GetConversationsByConversationIDMultipleOwner(OwnerUserIDList []string, conversationID string) ([]Conversation, error) { func GetConversationsByConversationIDMultipleOwner(OwnerUserIDList []string, conversationID string) ([]Conversation, error) {
var conversations []Conversation var conversations []Conversation
err := db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", OwnerUserIDList, conversationID).Find(&conversations).Error err := ConversationDB.Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", OwnerUserIDList, conversationID).Find(&conversations).Error
return conversations, err return conversations, err
} }
func UpdateColumnsConversations(ownerUserIDList []string, conversationID string, args map[string]interface{}) error { func UpdateColumnsConversations(ownerUserIDList []string, conversationID string, args map[string]interface{}) error {
return db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Updates(args).Error return ConversationDB.Model(&Conversation{}).Where("owner_user_id IN (?) and conversation_id=?", ownerUserIDList, conversationID).Updates(args).Error
} }
func GetConversationIDListByUserID(userID string) ([]string, error) { func GetConversationIDListByUserID(userID string) ([]string, error) {
var IDList []string var IDList []string
err := db.DB.MysqlDB.DefaultGormDB().Model(&Conversation{}).Where("owner_user_id=?", userID).Pluck("conversation_id", &IDList).Error err := ConversationDB.Model(&Conversation{}).Where("owner_user_id=?", userID).Pluck("conversation_id", &IDList).Error
return IDList, err return IDList, err
} }

34
pkg/common/db/mysql_model/im_mysql_model/demo_model.go
Unescape View File

@ -1,21 +1,31 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"errors" "errors"
"gorm.io/gorm"
_ "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) { func GetRegister(account, areaCode, userID string) (*Register, error) {
var r Register var r Register
return &r, db.DB.MysqlDB.DefaultGormDB().Table("registers").Where("user_id = ? and user_id != ? or account = ? or account =? and area_code=?", 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 userID, "", account, account, areaCode).Take(&r).Error
} }
func GetRegisterInfo(userID string) (*Register, error) { func GetRegisterInfo(userID string) (*Register, error) {
var r Register var r Register
return &r, db.DB.MysqlDB.DefaultGormDB().Table("registers").Where("user_id = ?", userID).Take(&r).Error return &r, RegisterDB.Table("registers").Where("user_id = ?", userID).Take(&r).Error
} }
func SetPassword(account, password, ex, userID, areaCode, ip string) error { func SetPassword(account, password, ex, userID, areaCode, ip string) error {
@ -27,20 +37,20 @@ func SetPassword(account, password, ex, userID, areaCode, ip string) error {
RegisterIP: ip, RegisterIP: ip,
AreaCode: areaCode, AreaCode: areaCode,
} }
return db.DB.MysqlDB.DefaultGormDB().Table("registers").Create(&r).Error return RegisterDB.Table("registers").Create(&r).Error
} }
func ResetPassword(account, password string) error { func ResetPassword(account, password string) error {
r := Register{ r := Register{
Password: password, Password: password,
} }
return db.DB.MysqlDB.DefaultGormDB().Table("registers").Where("account = ?", account).Updates(&r).Error return RegisterDB.Table("registers").Where("account = ?", account).Updates(&r).Error
} }
func GetRegisterAddFriendList(showNumber, pageNumber int32) ([]string, error) { func GetRegisterAddFriendList(showNumber, pageNumber int32) ([]string, error) {
var IDList []string var IDList []string
var err error var err error
model := db.DB.MysqlDB.DefaultGormDB().Model(&RegisterAddFriend{}) model := RegisterDB.Model(&RegisterAddFriend{})
if showNumber == 0 { if showNumber == 0 {
err = model.Pluck("user_id", &IDList).Error err = model.Pluck("user_id", &IDList).Error
} else { } else {
@ -54,7 +64,7 @@ func AddUserRegisterAddFriendIDList(userIDList ...string) error {
for _, v := range userIDList { for _, v := range userIDList {
list = append(list, RegisterAddFriend{UserID: v}) list = append(list, RegisterAddFriend{UserID: v})
} }
result := db.DB.MysqlDB.DefaultGormDB().Create(list) result := RegisterDB.Create(list)
if int(result.RowsAffected) < len(userIDList) { if int(result.RowsAffected) < len(userIDList) {
return errors.New("some line insert failed") return errors.New("some line insert failed")
} }
@ -67,18 +77,18 @@ func ReduceUserRegisterAddFriendIDList(userIDList ...string) error {
for _, v := range userIDList { for _, v := range userIDList {
list = append(list, RegisterAddFriend{UserID: v}) list = append(list, RegisterAddFriend{UserID: v})
} }
err := db.DB.MysqlDB.DefaultGormDB().Delete(list).Error err := RegisterDB.Delete(list).Error
return err return err
} }
func DeleteAllRegisterAddFriendIDList() error { func DeleteAllRegisterAddFriendIDList() error {
err := db.DB.MysqlDB.DefaultGormDB().Where("1 = 1").Delete(&RegisterAddFriend{}).Error err := RegisterDB.Where("1 = 1").Delete(&RegisterAddFriend{}).Error
return err return err
} }
func GetUserIPLimit(userID string) (UserIpLimit, error) { func GetUserIPLimit(userID string) (UserIpLimit, error) {
var limit UserIpLimit var limit UserIpLimit
limit.UserID = userID limit.UserID = userID
err := db.DB.MysqlDB.DefaultGormDB().Model(&UserIpLimit{}).Take(&limit).Error err := RegisterDB.Model(&UserIpLimit{}).Take(&limit).Error
return limit, err return limit, err
} }

10
pkg/common/db/mysql_model/im_mysql_model/file_model.go
Unescape View File

@ -1,10 +1,12 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db" "gorm.io/gorm"
"time" "time"
) )
var AppDB *gorm.DB
func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, yamlName, updateLog string) error { func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, yamlName, updateLog string) error {
updateTime := int(time.Now().Unix()) updateTime := int(time.Now().Unix())
app := AppVersion{ app := AppVersion{
@ -16,13 +18,13 @@ func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, y
ForceUpdate: forceUpdate, ForceUpdate: forceUpdate,
UpdateLog: updateLog, UpdateLog: updateLog,
} }
result := db.DB.MysqlDB.DefaultGormDB().Model(AppVersion{}).Where("type = ?", appType).Updates(map[string]interface{}{"force_update": forceUpdate, 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}) "version": version, "update_time": int(time.Now().Unix()), "file_name": fileName, "yaml_name": yamlName, "type": appType, "update_log": updateLog})
if result.Error != nil { if result.Error != nil {
return result.Error return result.Error
} }
if result.RowsAffected == 0 { if result.RowsAffected == 0 {
err := db.DB.MysqlDB.DefaultGormDB().Create(&app).Error err := AppDB.Create(&app).Error
return err return err
} }
return nil return nil
@ -30,5 +32,5 @@ func UpdateAppVersion(appType int, version string, forceUpdate bool, fileName, y
func GetNewestVersion(appType int) (*AppVersion, error) { func GetNewestVersion(appType int) (*AppVersion, error) {
app := AppVersion{} app := AppVersion{}
return &app, db.DB.MysqlDB.DefaultGormDB().Model(AppVersion{}).First(&app, appType).Error return &app, AppDB.Model(AppVersion{}).First(&app, appType).Error
} }

17
pkg/common/db/mysql_model/im_mysql_model/friend_model.go
Unescape View File

@ -1,14 +1,13 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"fmt" "fmt"
"time" "time"
) )
func InsertToFriend(toInsertFollow *Friend) error { func InsertToFriend(toInsertFollow *Friend) error {
toInsertFollow.CreateTime = time.Now() toInsertFollow.CreateTime = time.Now()
err := db.DB.MysqlDB.DefaultGormDB().Table("friends").Create(toInsertFollow).Error err := FriendDB.Table("friends").Create(toInsertFollow).Error
if err != nil { if err != nil {
return err return err
} }
@ -17,7 +16,7 @@ func InsertToFriend(toInsertFollow *Friend) error {
func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) { func GetFriendRelationshipFromFriend(OwnerUserID, FriendUserID string) (*Friend, error) {
var friend Friend var friend Friend
err := db.DB.MysqlDB.DefaultGormDB().Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Take(&friend).Error err := FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Take(&friend).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -28,7 +27,7 @@ func GetFriendListByUserID(OwnerUserID string) ([]Friend, error) {
var friends []Friend var friends []Friend
var x Friend var x Friend
x.OwnerUserID = OwnerUserID x.OwnerUserID = OwnerUserID
err := db.DB.MysqlDB.DefaultGormDB().Table("friends").Where("owner_user_id=?", OwnerUserID).Find(&friends).Error err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Find(&friends).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -37,7 +36,7 @@ func GetFriendListByUserID(OwnerUserID string) ([]Friend, error) {
func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) { func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
var friendIDList []string var friendIDList []string
err := db.DB.MysqlDB.DefaultGormDB().Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error err := FriendDB.Table("friends").Where("owner_user_id=?", OwnerUserID).Pluck("friend_user_id", &friendIDList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -45,11 +44,11 @@ func GetFriendIDListByUserID(OwnerUserID string) ([]string, error) {
} }
func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error { func UpdateFriendComment(OwnerUserID, FriendUserID, Remark string) error {
return db.DB.MysqlDB.DefaultGormDB().Exec("update friends set remark=? where owner_user_id=? and friend_user_id=?", Remark, OwnerUserID, FriendUserID).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 { func DeleteSingleFriendInfo(OwnerUserID, FriendUserID string) error {
return db.DB.MysqlDB.DefaultGormDB().Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(Friend{}).Error return FriendDB.Table("friends").Where("owner_user_id=? and friend_user_id=?", OwnerUserID, FriendUserID).Delete(Friend{}).Error
} }
type FriendUser struct { type FriendUser struct {
@ -58,7 +57,7 @@ type FriendUser struct {
} }
func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumber int32) (friendUserList []*FriendUser, count int64, err error) { func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumber int32) (friendUserList []*FriendUser, count int64, err error) {
db := db.DB.MysqlDB.DefaultGormDB().Table("friends"). db := FriendDB.Table("friends").
Select("friends.*, users.name"). Select("friends.*, users.name").
Where("friends.owner_user_id=?", ownerUserID).Limit(int(showNumber)). Where("friends.owner_user_id=?", ownerUserID).Limit(int(showNumber)).
Joins("left join users on friends.friend_user_id = users.user_id"). Joins("left join users on friends.friend_user_id = users.user_id").
@ -75,7 +74,7 @@ func GetUserFriendsCMS(ownerUserID, friendUserName string, pageNumber, showNumbe
func GetFriendByIDCMS(ownerUserID, friendUserID string) (friendUser *FriendUser, err error) { func GetFriendByIDCMS(ownerUserID, friendUserID string) (friendUser *FriendUser, err error) {
friendUser = &FriendUser{} friendUser = &FriendUser{}
err = db.DB.MysqlDB.DefaultGormDB().Table("friends"). err = FriendDB.Table("friends").
Select("friends.*, users.name"). Select("friends.*, users.name").
Where("friends.owner_user_id=? and friends.friend_user_id=?", ownerUserID, friendUserID). Where("friends.owner_user_id=? and friends.friend_user_id=?", ownerUserID, friendUserID).
Joins("left join users on friends.friend_user_id = users.user_id"). Joins("left join users on friends.friend_user_id = users.user_id").

13
pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go
Unescape View File

@ -1,7 +1,6 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
@ -25,7 +24,7 @@ func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Create(&friends).Error, "") err = utils.Wrap(FriendDB.Create(&friends).Error, "")
return err return err
} }
@ -33,7 +32,7 @@ func (*Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []s
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
return err return err
} }
@ -41,27 +40,27 @@ func (*Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[str
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "") return utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
} }
func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) { func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Updates(&friends).Error, "") return utils.Wrap(FriendDB.Updates(&friends).Error, "")
} }
func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
return friends, err return friends, err
} }
func (*Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (group *Group, err error) { func (*Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (group *Group, err error) {
group = &Group{} group = &Group{}
defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *group) defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *group)
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(group).Error, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(group).Error, "")
return group, err return group, err
} }

44
pkg/common/db/mysql_model/im_mysql_model/friend_request_model.go
Unescape View File

@ -1,27 +1,33 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"gorm.io/gorm"
"time" "time"
) )
//type FriendRequest struct { var FriendRequestDB *gorm.DB
// FromUserID string `gorm:"column:from_user_id;primaryKey;"`
// ToUserID string `gorm:"column:to_user_id;primaryKey;"` type FriendRequest struct {
// HandleResult int32 `gorm:"column:handle_result"` FromUserID string `gorm:"column:from_user_id;primary_key;size:64"`
// ReqMessage string `gorm:"column:req_message"` ToUserID string `gorm:"column:to_user_id;primary_key;size:64"`
// CreateTime time.Time `gorm:"column:create_time"` HandleResult int32 `gorm:"column:handle_result"`
// HandlerUserID string `gorm:"column:handler_user_id"` ReqMsg string `gorm:"column:req_msg;size:255"`
// HandleMsg string `gorm:"column:handle_msg"` CreateTime time.Time `gorm:"column:create_time"`
// HandleTime time.Time `gorm:"column:handle_time"` HandlerUserID string `gorm:"column:handler_user_id;size:64"`
// Ex string `gorm:"column:ex"` 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"
}
// who apply to add me // who apply to add me
func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest, error) { func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest, error) {
var usersInfo []FriendRequest var usersInfo []FriendRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Where("to_user_id=?", ToUserID).Find(&usersInfo).Error err := FriendRequestDB.Table("friend_requests").Where("to_user_id=?", ToUserID).Find(&usersInfo).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -31,7 +37,7 @@ func GetReceivedFriendsApplicationListByUserID(ToUserID string) ([]FriendRequest
// I apply to add somebody // I apply to add somebody
func GetSendFriendApplicationListByUserID(FromUserID string) ([]FriendRequest, error) { func GetSendFriendApplicationListByUserID(FromUserID string) ([]FriendRequest, error) {
var usersInfo []FriendRequest var usersInfo []FriendRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Where("from_user_id=?", FromUserID).Find(&usersInfo).Error err := FriendRequestDB.Table("friend_requests").Where("from_user_id=?", FromUserID).Find(&usersInfo).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -41,7 +47,7 @@ func GetSendFriendApplicationListByUserID(FromUserID string) ([]FriendRequest, e
// FromUserId apply to add ToUserID // FromUserId apply to add ToUserID
func GetFriendApplicationByBothUserID(FromUserID, ToUserID string) (*FriendRequest, error) { func GetFriendApplicationByBothUserID(FromUserID, ToUserID string) (*FriendRequest, error) {
var friendRequest FriendRequest var friendRequest FriendRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Where("from_user_id=? and to_user_id=?", FromUserID, ToUserID).Take(&friendRequest).Error err := FriendRequestDB.Table("friend_requests").Where("from_user_id=? and to_user_id=?", FromUserID, ToUserID).Take(&friendRequest).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -50,12 +56,12 @@ func GetFriendApplicationByBothUserID(FromUserID, ToUserID string) (*FriendReque
func UpdateFriendApplication(friendRequest *FriendRequest) error { func UpdateFriendApplication(friendRequest *FriendRequest) error {
friendRequest.CreateTime = time.Now() friendRequest.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Where("from_user_id=? and to_user_id=?", return FriendRequestDB.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
friendRequest.FromUserID, friendRequest.ToUserID).Updates(&friendRequest).Error friendRequest.FromUserID, friendRequest.ToUserID).Updates(&friendRequest).Error
} }
func InsertFriendApplication(friendRequest *FriendRequest, args map[string]interface{}) error { func InsertFriendApplication(friendRequest *FriendRequest, args map[string]interface{}) error {
if err := db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Create(friendRequest).Error; err == nil { if err := FriendRequestDB.Table("friend_requests").Create(friendRequest).Error; err == nil {
return nil return nil
} }
@ -67,7 +73,7 @@ func InsertFriendApplication(friendRequest *FriendRequest, args map[string]inter
friendRequest.CreateTime = time.Now() friendRequest.CreateTime = time.Now()
args["create_time"] = friendRequest.CreateTime args["create_time"] = friendRequest.CreateTime
u := db.DB.MysqlDB.DefaultGormDB().Model(friendRequest).Updates(args) u := FriendRequestDB.Model(friendRequest).Updates(args)
//u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?", //u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
// friendRequest.FromUserID, friendRequest.ToUserID).Update(&friendRequest) // friendRequest.FromUserID, friendRequest.ToUserID).Update(&friendRequest)
//u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?", //u := dbConn.Table("friend_requests").Where("from_user_id=? and to_user_id=?",
@ -82,7 +88,7 @@ func InsertFriendApplication(friendRequest *FriendRequest, args map[string]inter
if friendRequest.HandleTime.Unix() < 0 { if friendRequest.HandleTime.Unix() < 0 {
friendRequest.HandleTime = utils.UnixSecondToTime(0) friendRequest.HandleTime = utils.UnixSecondToTime(0)
} }
err := db.DB.MysqlDB.DefaultGormDB().Table("friend_requests").Create(friendRequest).Error err := FriendRequestDB.Table("friend_requests").Create(friendRequest).Error
if err != nil { if err != nil {
return err return err
} }

62
pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go
Unescape View File

@ -2,7 +2,6 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
@ -11,18 +10,6 @@ import (
"time" "time"
) )
//type GroupMember struct {
// GroupID string `gorm:"column:group_id;primaryKey;"`
// UserID string `gorm:"column:user_id;primaryKey;"`
// NickName string `gorm:"column:nickname"`
// FaceUrl string `gorm:"user_group_face_url"`
// RoleLevel int32 `gorm:"column:role_level"`
// JoinTime time.Time `gorm:"column:join_time"`
// JoinSource int32 `gorm:"column:join_source"`
// OperatorUserID string `gorm:"column:operator_user_id"`
// Ex string `gorm:"column:ex"`
//}
var GroupMemberDB *gorm.DB var GroupMemberDB *gorm.DB
type GroupMember struct { type GroupMember struct {
@ -44,26 +31,26 @@ func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
}() }()
return utils.Wrap(g.DB.Create(&groupMemberList).Error, "") return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "")
} }
func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) { func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
}() }()
return utils.Wrap(g.DB.Delete(groupMembers).Error, "") return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "")
} }
func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) { func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
}() }()
return utils.Wrap(g.DB.Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "") 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) { func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember) (err error) {
defer func() { trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }() defer func() { trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
return utils.Wrap(g.DB.Updates(&groupMembers).Error, "") return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "")
} }
func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) { func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) {
@ -74,7 +61,7 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (gr
for _, groupMember := range groupMembers { for _, groupMember := range groupMembers {
where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID}) where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
} }
err = utils.Wrap(g.DB.Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "") err = utils.Wrap(GroupMemberDB.Where("(group_id, user_id) in ?", where).Find(&groupList).Error, "")
return groupList, err return groupList, err
} }
@ -83,7 +70,7 @@ func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
}() }()
groupMember = &GroupMember{} groupMember = &GroupMember{}
return groupMember, utils.Wrap(g.DB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "") 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) { func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) {
@ -91,7 +78,7 @@ func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupM
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
}() }()
groupMember = &GroupMember{} groupMember = &GroupMember{}
err = g.DB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error
return groupMember, utils.Wrap(err, "") return groupMember, utils.Wrap(err, "")
} }
@ -183,7 +170,7 @@ func UpdateGroupMemberInfoByMap(groupMemberInfo GroupMember, m map[string]interf
func GetOwnerManagerByGroupID(groupID string) ([]GroupMember, error) { func GetOwnerManagerByGroupID(groupID string) ([]GroupMember, error) {
var groupMemberList []GroupMember var groupMemberList []GroupMember
err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=? and role_level>?", groupID, constant.GroupOrdinaryUsers).Find(&groupMemberList).Error err := GroupMemberDB.Table("group_members").Where("group_id=? and role_level>?", groupID, constant.GroupOrdinaryUsers).Find(&groupMemberList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -192,7 +179,7 @@ func GetOwnerManagerByGroupID(groupID string) ([]GroupMember, error) {
func GetGroupMemberNumByGroupID(groupID string) (int64, error) { func GetGroupMemberNumByGroupID(groupID string) (int64, error) {
var number int64 var number int64
err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id=?", groupID).Count(&number).Error err := GroupMemberDB.Table("group_members").Where("group_id=?", groupID).Count(&number).Error
if err != nil { if err != nil {
return 0, utils.Wrap(err, "") return 0, utils.Wrap(err, "")
} }
@ -209,12 +196,12 @@ func GetGroupOwnerInfoByGroupID(groupID string) (*GroupMember, error) {
return &v, nil return &v, nil
} }
} }
return nil, utils.Wrap(constant.ErrNoGroupOwner, "") return nil, utils.Wrap(constant.ErrGroupNoOwner, "")
} }
func IsExistGroupMember(groupID, userID string) bool { func IsExistGroupMember(groupID, userID string) bool {
var number int64 var number int64
err := db.DB.MysqlDB.DefaultGormDB().Table("group_members").Where("group_id = ? and user_id = ?", groupID, userID).Count(&number).Error err := GroupMemberDB.Table("group_members").Where("group_id = ? and user_id = ?", groupID, userID).Count(&number).Error
if err != nil { if err != nil {
return false return false
} }
@ -276,7 +263,7 @@ func IsGroupOwnerAdmin(groupID, UserID string) bool {
func GetGroupMembersByGroupIdCMS(groupId string, userName string, showNumber, pageNumber int32) ([]GroupMember, error) { func GetGroupMembersByGroupIdCMS(groupId string, userName string, showNumber, pageNumber int32) ([]GroupMember, error) {
var groupMembers []GroupMember 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 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 { if err != nil {
return nil, err return nil, err
} }
@ -285,33 +272,12 @@ func GetGroupMembersByGroupIdCMS(groupId string, userName string, showNumber, pa
func GetGroupMembersCount(groupID, userName string) (int64, error) { func GetGroupMembersCount(groupID, userName string) (int64, error) {
var count int64 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 { 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, err
} }
return count, nil return count, nil
} }
func UpdateGroupMemberInfoDefaultZero(groupMemberInfo GroupMember, args map[string]interface{}) error { func UpdateGroupMemberInfoDefaultZero(groupMemberInfo GroupMember, args map[string]interface{}) error {
return db.DB.MysqlDB.DefaultGormDB().Model(groupMemberInfo).Updates(args).Error return GroupMemberDB.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
//}

32
pkg/common/db/mysql_model/im_mysql_model/group_model.go
Unescape View File

@ -2,26 +2,12 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"fmt" "fmt"
"time" "time"
) )
//type Group struct {
// GroupID string `gorm:"column:group_id;primaryKey;"`
// GroupName string `gorm:"column:name"`
// Introduction string `gorm:"column:introduction"`
// Notification string `gorm:"column:notification"`
// FaceUrl string `gorm:"column:face_url"`
// CreateTime time.Time `gorm:"column:create_time"`
// Status int32 `gorm:"column:status"`
// CreatorUserID string `gorm:"column:creator_user_id"`
// GroupType int32 `gorm:"column:group_type"`
// Ex string `gorm:"column:ex"`
//}
func InsertIntoGroup(groupInfo Group) error { func InsertIntoGroup(groupInfo Group) error {
if groupInfo.GroupName == "" { if groupInfo.GroupName == "" {
groupInfo.GroupName = "Group Chat" groupInfo.GroupName = "Group Chat"
@ -31,7 +17,7 @@ func InsertIntoGroup(groupInfo Group) error {
if groupInfo.NotificationUpdateTime.Unix() < 0 { if groupInfo.NotificationUpdateTime.Unix() < 0 {
groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0) groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0)
} }
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Create(groupInfo).Error err := GroupDB.Create(groupInfo).Error
if err != nil { if err != nil {
return err return err
} }
@ -40,18 +26,18 @@ func InsertIntoGroup(groupInfo Group) error {
func TakeGroupInfoByGroupID(groupID string) (*Group, error) { func TakeGroupInfoByGroupID(groupID string) (*Group, error) {
var groupInfo Group var groupInfo Group
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_id=?", groupID).Take(&groupInfo).Error err := GroupDB.Where("group_id=?", groupID).Take(&groupInfo).Error
return &groupInfo, err return &groupInfo, err
} }
func GetGroupInfoByGroupID(groupID string) (*Group, error) { func GetGroupInfoByGroupID(groupID string) (*Group, error) {
var groupInfo Group var groupInfo Group
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_id=?", groupID).Take(&groupInfo).Error err := GroupDB.Where("group_id=?", groupID).Take(&groupInfo).Error
return &groupInfo, err return &groupInfo, err
} }
func SetGroupInfo(groupInfo Group) error { func SetGroupInfo(groupInfo Group) error {
return db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_id=?", groupInfo.GroupID).Updates(&groupInfo).Error return GroupDB.Where("group_id=?", groupInfo.GroupID).Updates(&groupInfo).Error
} }
type GroupWithNum struct { type GroupWithNum struct {
@ -62,7 +48,7 @@ type GroupWithNum struct {
func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]GroupWithNum, int64, error) { func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]GroupWithNum, int64, error) {
var groups []GroupWithNum var groups []GroupWithNum
var count int64 var count int64
sql := db.DB.MysqlDB.DefaultGormDB().Table("groups").Select("groups.*, (select count(*) from group_members where group_members.group_id=groups.group_id) as num"). 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) Where(" name like ? and status != ?", fmt.Sprintf("%%%s%%", groupName), constant.GroupStatusDismissed)
if err := sql.Count(&count).Error; err != nil { if err := sql.Count(&count).Error; err != nil {
return nil, 0, err return nil, 0, err
@ -73,7 +59,7 @@ func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]GroupWit
func GetGroups(pageNumber, showNumber int) ([]GroupWithNum, error) { func GetGroups(pageNumber, showNumber int) ([]GroupWithNum, error) {
var groups []GroupWithNum var groups []GroupWithNum
if err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Select("groups.*, (select count(*) from group_members where group_members.group_id=groups.group_id) as num"). 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 { Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groups).Error; err != nil {
return groups, err return groups, err
} }
@ -93,19 +79,19 @@ func OperateGroupStatus(groupId string, groupStatus int32) error {
func GetGroupsCountNum(group Group) (int32, error) { func GetGroupsCountNum(group Group) (int32, error) {
var count int64 var count int64
if err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where(" name like ? ", fmt.Sprintf("%%%s%%", group.GroupName)).Count(&count).Error; err != nil { if err := GroupDB.Where(" name like ? ", fmt.Sprintf("%%%s%%", group.GroupName)).Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return int32(count), nil return int32(count), nil
} }
func UpdateGroupInfoDefaultZero(groupID string, args map[string]interface{}) error { func UpdateGroupInfoDefaultZero(groupID string, args map[string]interface{}) error {
return db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_id = ? ", groupID).Updates(args).Error return GroupDB.Where("group_id = ? ", groupID).Updates(args).Error
} }
func GetGroupIDListByGroupType(groupType int) ([]string, error) { func GetGroupIDListByGroupType(groupType int) ([]string, error) {
var groupIDList []string var groupIDList []string
if err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_type = ? ", groupType).Pluck("group_id", &groupIDList).Error; err != nil { if err := GroupDB.Where("group_type = ? ", groupType).Pluck("group_id", &groupIDList).Error; err != nil {
return nil, err return nil, err
} }
return groupIDList, nil return groupIDList, nil

17
pkg/common/db/mysql_model/im_mysql_model/group_model_k.go
Unescape View File

@ -1,13 +1,15 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"gorm.io/gorm"
"time" "time"
) )
var GroupDB *gorm.DB
type Group struct { type Group struct {
GroupID string `gorm:"column:group_id;primary_key;size:64" json:"groupID" 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"` GroupName string `gorm:"column:name;size:255" json:"groupName"`
@ -24,13 +26,14 @@ type Group struct {
ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"` ApplyMemberFriend int32 `gorm:"column:apply_member_friend" json:"applyMemberFriend"`
NotificationUpdateTime time.Time `gorm:"column:notification_update_time"` NotificationUpdateTime time.Time `gorm:"column:notification_update_time"`
NotificationUserID string `gorm:"column:notification_user_id;size:64"` NotificationUserID string `gorm:"column:notification_user_id;size:64"`
GroupDB *gorm.DB
} }
func (*Group) Create(ctx context.Context, groups []*Group) (err error) { func (*Group) Create(ctx context.Context, groups []*Group) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Create(&groups).Error, "") err = utils.Wrap(GroupDB.Create(&groups).Error, "")
return err return err
} }
@ -38,28 +41,28 @@ func (*Group) Delete(ctx context.Context, groupIDs []string) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "") 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) { func (*Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id = ?", groupID).Updates(args).Error, "") return utils.Wrap(GroupDB.Where("group_id = ?", groupID).Updates(args).Error, "")
} }
func (*Group) Update(ctx context.Context, groups []*Group) (err error) { func (*Group) Update(ctx context.Context, groups []*Group) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Updates(&groups).Error, "") return utils.Wrap(GroupDB.Updates(&groups).Error, "")
} }
func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, err error) { func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDList", groupIDs, "groupList", groupList) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDList", groupIDs, "groupList", groupList)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id in (?)", groupIDs).Find(&groupList).Error, "") err = utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Find(&groupList).Error, "")
return groupList, err return groupList, err
} }
@ -68,6 +71,6 @@ func (*Group) Take(ctx context.Context, groupID string) (group *Group, err error
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group) trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
}() }()
err = utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id = ?", groupID).Take(group).Error, "") err = utils.Wrap(GroupDB.Where("group_id = ?", groupID).Take(group).Error, "")
return group, err return group, err
} }

95
pkg/common/db/mysql_model/im_mysql_model/group_request_model.go
Unescape View File

@ -1,12 +1,5 @@
package im_mysql_model package im_mysql_model
import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils"
"time"
)
//type GroupRequest struct { //type GroupRequest struct {
// UserID string `gorm:"column:user_id;primaryKey;"` // UserID string `gorm:"column:user_id;primaryKey;"`
// GroupID string `gorm:"column:group_id;primaryKey;"` // GroupID string `gorm:"column:group_id;primaryKey;"`
@ -26,27 +19,27 @@ import (
// return db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=? and user_id=?", groupRequest.GroupID, groupRequest.UserID).Updates(&groupRequest).Error // 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 { //func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
DelGroupRequestByGroupIDAndUserID(toInsertInfo.GroupID, toInsertInfo.UserID) // DelGroupRequestByGroupIDAndUserID(toInsertInfo.GroupID, toInsertInfo.UserID)
if toInsertInfo.HandledTime.Unix() < 0 { // if toInsertInfo.HandledTime.Unix() < 0 {
toInsertInfo.HandledTime = utils.UnixSecondToTime(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) // u := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=? and user_id=?", toInsertInfo.GroupID, toInsertInfo.UserID).Updates(&toInsertInfo)
if u.RowsAffected != 0 { // if u.RowsAffected != 0 {
return nil // return nil
} // }
//
toInsertInfo.ReqTime = time.Now() // toInsertInfo.ReqTime = time.Now()
if toInsertInfo.HandledTime.Unix() < 0 { // if toInsertInfo.HandledTime.Unix() < 0 {
toInsertInfo.HandledTime = utils.UnixSecondToTime(0) // toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
} // }
//
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Create(&toInsertInfo).Error // err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Create(&toInsertInfo).Error
if err != nil { // if err != nil {
return err // return err
} // }
return nil // return nil
} //}
//func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, error) { //func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, error) {
// var groupRequest GroupRequest // var groupRequest GroupRequest
@ -71,29 +64,29 @@ func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
//} //}
// received // received
func GetRecvGroupApplicationList(userID string) ([]GroupRequest, error) { //func GetRecvGroupApplicationList(userID string) ([]GroupRequest, error) {
var groupRequestList []GroupRequest // var groupRequestList []GroupRequest
memberList, err := GetGroupMemberListByUserID(userID) // memberList, err := GetGroupMemberListByUserID(userID)
if err != nil { // if err != nil {
return nil, utils.Wrap(err, utils.GetSelfFuncName()) // return nil, utils.Wrap(err, utils.GetSelfFuncName())
} // }
for _, v := range memberList { // for _, v := range memberList {
if v.RoleLevel > constant.GroupOrdinaryUsers { // if v.RoleLevel > constant.GroupOrdinaryUsers {
list, err := GetGroupRequestByGroupID(v.GroupID) // list, err := GetGroupRequestByGroupID(v.GroupID)
if err != nil { // if err != nil {
continue // continue
} // }
groupRequestList = append(groupRequestList, list...) // groupRequestList = append(groupRequestList, list...)
} // }
} // }
return groupRequestList, nil // return groupRequestList, nil
} //}
//
func GetUserReqGroupByUserID(userID string) ([]GroupRequest, error) { //func GetUserReqGroupByUserID(userID string) ([]GroupRequest, error) {
var groupRequestList []GroupRequest // var groupRequestList []GroupRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error // err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error
return groupRequestList, err // return groupRequestList, err
} //}
// //
//func GroupApplicationResponse(pb *group.GroupApplicationResponseReq) (*group.CommonResp, error) { //func GroupApplicationResponse(pb *group.GroupApplicationResponseReq) (*group.CommonResp, error) {

28
pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go
Unescape View File

@ -2,13 +2,15 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"gorm.io/gorm"
"time" "time"
) )
var GroupRequestDB *gorm.DB
type GroupRequest struct { type GroupRequest struct {
UserID string `gorm:"column:user_id;primary_key;size:64"` UserID string `gorm:"column:user_id;primary_key;size:64"`
GroupID string `gorm:"column:group_id;primary_key;size:64"` GroupID string `gorm:"column:group_id;primary_key;size:64"`
@ -27,28 +29,28 @@ func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest)
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Create(&groupRequests).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Delete(&groupRequests).Error, utils.GetSelfFuncName()) 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) { func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "args", args) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "args", args)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id = ? and user_id = ? ", groupID, userID).Updates(args).Error, utils.GetSelfFuncName()) 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) { func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Updates(&groupRequests).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) { func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) {
@ -59,7 +61,7 @@ func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (r
for _, groupMember := range groupRequests { for _, groupMember := range groupRequests {
where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID}) where = append(where, []interface{}{groupMember.GroupID, groupMember.UserID})
} }
return resultGroupRequests, utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("(group_id, user_id) in ?", where).Find(&resultGroupRequests).Error, utils.GetSelfFuncName()) 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) { func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) {
@ -67,7 +69,7 @@ func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (g
defer func() { defer func() {
trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest) trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest)
}() }()
return groupRequest, utils.Wrap(db.DB.MysqlDB.DefaultGormDB().Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName()) return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
} }
//func UpdateGroupRequest(groupRequest GroupRequest) error { //func UpdateGroupRequest(groupRequest GroupRequest) error {
@ -82,7 +84,7 @@ func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
if toInsertInfo.HandledTime.Unix() < 0 { if toInsertInfo.HandledTime.Unix() < 0 {
toInsertInfo.HandledTime = utils.UnixSecondToTime(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) u := GroupRequestDB.Table("group_requests").Where("group_id=? and user_id=?", toInsertInfo.GroupID, toInsertInfo.UserID).Updates(&toInsertInfo)
if u.RowsAffected != 0 { if u.RowsAffected != 0 {
return nil return nil
} }
@ -92,7 +94,7 @@ func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
toInsertInfo.HandledTime = utils.UnixSecondToTime(0) toInsertInfo.HandledTime = utils.UnixSecondToTime(0)
} }
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Create(&toInsertInfo).Error err := GroupRequestDB.Create(&toInsertInfo).Error
if err != nil { if err != nil {
return err return err
} }
@ -101,7 +103,7 @@ func InsertIntoGroupRequest(toInsertInfo GroupRequest) error {
func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, error) { func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, error) {
var groupRequest GroupRequest var groupRequest GroupRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("user_id=? and group_id=?", userID, groupID).Take(&groupRequest).Error err := GroupRequestDB.Where("user_id=? and group_id=?", userID, groupID).Take(&groupRequest).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -109,12 +111,12 @@ func GetGroupRequestByGroupIDAndUserID(groupID, userID string) (*GroupRequest, e
} }
func DelGroupRequestByGroupIDAndUserID(groupID, userID string) error { 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 return GroupRequestDB.Table("group_requests").Where("group_id=? and user_id=?", groupID, userID).Delete(GroupRequest{}).Error
} }
func GetGroupRequestByGroupID(groupID string) ([]GroupRequest, error) { func GetGroupRequestByGroupID(groupID string) ([]GroupRequest, error) {
var groupRequestList []GroupRequest var groupRequestList []GroupRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("group_id=?", groupID).Find(&groupRequestList).Error err := GroupRequestDB.Table("group_requests").Where("group_id=?", groupID).Find(&groupRequestList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -142,7 +144,7 @@ func GetRecvGroupApplicationList(userID string) ([]GroupRequest, error) {
func GetUserReqGroupByUserID(userID string) ([]GroupRequest, error) { func GetUserReqGroupByUserID(userID string) ([]GroupRequest, error) {
var groupRequestList []GroupRequest var groupRequestList []GroupRequest
err := db.DB.MysqlDB.DefaultGormDB().Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error err := GroupRequestDB.Table("group_requests").Where("user_id=?", userID).Find(&groupRequestList).Error
return groupRequestList, err return groupRequestList, err
} }

24
pkg/common/db/mysql_model/im_mysql_model/invitation_model.go
Unescape View File

@ -1,12 +1,22 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"errors" "errors"
"gorm.io/gorm"
"math/rand" "math/rand"
"time" "time"
) )
var InvitationDB *gorm.DB
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"`
}
/** /**
* 批量生成邀请码 * 批量生成邀请码
*/ */
@ -24,7 +34,7 @@ func BatchCreateInvitationCodes(CodeNums int, CodeLen int) ([]string, error) {
invitation.LastTime = time.Now() invitation.LastTime = time.Now()
invitation.Status = 0 invitation.Status = 0
invitation.UserID = "" invitation.UserID = ""
result := db.DB.MysqlDB.DefaultGormDB().Table("invitations").Create(&invitation) result := InvitationDB.Table("invitations").Create(&invitation)
if result.Error != nil { if result.Error != nil {
continue continue
} }
@ -41,7 +51,7 @@ func BatchCreateInvitationCodes(CodeNums int, CodeLen int) ([]string, error) {
*/ */
func CheckInvitationCode(code string) error { func CheckInvitationCode(code string) error {
var invitationCode Invitation var invitationCode Invitation
err := db.DB.MysqlDB.DefaultGormDB().Table("invitations").Where("invitation_code=?", code).Take(&invitationCode).Error err := InvitationDB.Table("invitations").Where("invitation_code=?", code).Take(&invitationCode).Error
if err != nil { if err != nil {
return err return err
} }
@ -62,7 +72,7 @@ func TryLockInvitationCode(Code string, UserID string) bool {
Data["user_id"] = UserID Data["user_id"] = UserID
Data["status"] = 1 Data["status"] = 1
Data["last_time"] = time.Now() Data["last_time"] = time.Now()
result := db.DB.MysqlDB.DefaultGormDB().Table("invitations").Where("invitation_code=? and user_id=? and status=?", Code, "", 0).Updates(Data) result := InvitationDB.Table("invitations").Where("invitation_code=? and user_id=? and status=?", Code, "", 0).Updates(Data)
if result.Error != nil { if result.Error != nil {
return false return false
} }
@ -75,7 +85,7 @@ func TryLockInvitationCode(Code string, UserID string) bool {
func FinishInvitationCode(Code string, UserId string) bool { func FinishInvitationCode(Code string, UserId string) bool {
Data := make(map[string]interface{}, 0) Data := make(map[string]interface{}, 0)
Data["status"] = 2 Data["status"] = 2
result := db.DB.MysqlDB.DefaultGormDB().Table("invitations").Where("invitation_code=? and user_id=? and status=?", Code, UserId, 1).Updates(Data) result := InvitationDB.Table("invitations").Where("invitation_code=? and user_id=? and status=?", Code, UserId, 1).Updates(Data)
if result.Error != nil { if result.Error != nil {
return false return false
} }
@ -86,7 +96,7 @@ func GetInvitationCode(code string) (*Invitation, error) {
invitation := &Invitation{ invitation := &Invitation{
InvitationCode: code, InvitationCode: code,
} }
err := db.DB.MysqlDB.DefaultGormDB().Model(invitation).Find(invitation).Error err := InvitationDB.Model(invitation).Find(invitation).Error
return invitation, err return invitation, err
} }
@ -103,7 +113,7 @@ func CreateRandomString(strlen int) string {
func GetInvitationCodes(showNumber, pageNumber, status int32) ([]Invitation, int64, error) { func GetInvitationCodes(showNumber, pageNumber, status int32) ([]Invitation, int64, error) {
var invitationList []Invitation var invitationList []Invitation
db := db.DB.MysqlDB.DefaultGormDB().Model(Invitation{}).Where("status=?", status) db := InvitationDB.Model(Invitation{}).Where("status=?", status)
var count int64 var count int64
err := db.Count(&count).Error err := db.Count(&count).Error
err = db.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))). err = db.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).

55
pkg/common/db/mysql_model/im_mysql_model/ip_model.go
Unescape View File

@ -1,17 +1,42 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"time" "time"
"gorm.io/gorm" "gorm.io/gorm"
) )
var IPDB *gorm.DB
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"`
}
func IsLimitRegisterIp(RegisterIp string) (bool, error) { func IsLimitRegisterIp(RegisterIp string) (bool, error) {
//如果已经存在则限制 //如果已经存在则限制
var count int64 var count int64
if err := db.DB.MysqlDB.DefaultGormDB().Table("ip_limits").Where("ip=? and limit_register=? and limit_time>now()", RegisterIp, 1).Count(&count).Error; err != nil { if err := IPDB.Table("ip_limits").Where("ip=? and limit_register=? and limit_time>now()", RegisterIp, 1).Count(&count).Error; err != nil {
return false, err return false, err
} }
return count > 0, nil return count > 0, nil
@ -20,7 +45,7 @@ func IsLimitRegisterIp(RegisterIp string) (bool, error) {
func IsLimitLoginIp(LoginIp string) (bool, error) { func IsLimitLoginIp(LoginIp string) (bool, error) {
//如果已经存在则限制 //如果已经存在则限制
var count int64 var count int64
if err := db.DB.MysqlDB.DefaultGormDB().Table("ip_limits").Where("ip=? and limit_login=? and limit_time>now()", LoginIp, 1).Count(&count).Error; err != nil { if err := IPDB.Table("ip_limits").Where("ip=? and limit_login=? and limit_time>now()", LoginIp, 1).Count(&count).Error; err != nil {
return false, err return false, err
} }
return count > 0, nil return count > 0, nil
@ -29,14 +54,14 @@ func IsLimitLoginIp(LoginIp string) (bool, error) {
func IsLimitUserLoginIp(userID string, loginIp string) (limit bool, err error) { func IsLimitUserLoginIp(userID string, loginIp string) (limit bool, err error) {
//如果已经存在则放行 //如果已经存在则放行
var count int64 var count int64
result := db.DB.MysqlDB.DefaultGormDB().Table("user_ip_limits").Where("user_id=?", userID).Count(&count) result := IPDB.Table("user_ip_limits").Where("user_id=?", userID).Count(&count)
if err := result.Error; err != nil { if err := result.Error; err != nil {
return true, err return true, err
} }
if count < 1 { if count < 1 {
return false, nil return false, nil
} }
result = db.DB.MysqlDB.DefaultGormDB().Table("user_ip_limits").Where("user_id=? and ip = ?", userID, loginIp).Count(&count) result = IPDB.Table("user_ip_limits").Where("user_id=? and ip = ?", userID, loginIp).Count(&count)
if err := result.Error; err != nil { if err := result.Error; err != nil {
return true, err return true, err
} }
@ -46,56 +71,56 @@ func IsLimitUserLoginIp(userID string, loginIp string) (limit bool, err error) {
func QueryIPLimits(ip string) (*IpLimit, error) { func QueryIPLimits(ip string) (*IpLimit, error) {
var ipLimit IpLimit var ipLimit IpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&IpLimit{}).Where("ip=?", ip).First(&ipLimit).Error err := IPDB.Model(&IpLimit{}).Where("ip=?", ip).First(&ipLimit).Error
return &ipLimit, err return &ipLimit, err
} }
func QueryUserIPLimits(ip string) ([]UserIpLimit, error) { func QueryUserIPLimits(ip string) ([]UserIpLimit, error) {
var ips []UserIpLimit var ips []UserIpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&UserIpLimit{}).Where("ip=?", ip).Find(&ips).Error err := IPDB.Model(&UserIpLimit{}).Where("ip=?", ip).Find(&ips).Error
return ips, err return ips, err
} }
func InsertOneIntoIpLimits(ipLimits IpLimit) error { func InsertOneIntoIpLimits(ipLimits IpLimit) error {
return db.DB.MysqlDB.DefaultGormDB().Model(&IpLimit{}).Create(ipLimits).Error return IPDB.Model(&IpLimit{}).Create(ipLimits).Error
} }
func DeleteOneFromIpLimits(ip string) error { func DeleteOneFromIpLimits(ip string) error {
ipLimits := &IpLimit{Ip: ip} ipLimits := &IpLimit{Ip: ip}
return db.DB.MysqlDB.DefaultGormDB().Model(ipLimits).Where("ip=?", ip).Delete(ipLimits).Error return IPDB.Model(ipLimits).Where("ip=?", ip).Delete(ipLimits).Error
} }
func GetIpLimitsLoginByUserID(userID string) ([]UserIpLimit, error) { func GetIpLimitsLoginByUserID(userID string) ([]UserIpLimit, error) {
var ips []UserIpLimit var ips []UserIpLimit
err := db.DB.MysqlDB.DefaultGormDB().Model(&UserIpLimit{}).Where("user_id=?", userID).Find(&ips).Error err := IPDB.Model(&UserIpLimit{}).Where("user_id=?", userID).Find(&ips).Error
return ips, err return ips, err
} }
func InsertUserIpLimitsLogin(userIp *UserIpLimit) error { func InsertUserIpLimitsLogin(userIp *UserIpLimit) error {
userIp.CreateTime = time.Now() userIp.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Model(&UserIpLimit{}).Create(userIp).Error return IPDB.Model(&UserIpLimit{}).Create(userIp).Error
} }
func DeleteUserIpLimitsLogin(userID, ip string) error { func DeleteUserIpLimitsLogin(userID, ip string) error {
userIp := UserIpLimit{UserID: userID, Ip: ip} userIp := UserIpLimit{UserID: userID, Ip: ip}
return db.DB.MysqlDB.DefaultGormDB().Model(&UserIpLimit{}).Delete(&userIp).Error return IPDB.Model(&UserIpLimit{}).Delete(&userIp).Error
} }
func GetRegisterUserNum(ip string) ([]string, error) { func GetRegisterUserNum(ip string) ([]string, error) {
var userIDList []string var userIDList []string
err := db.DB.MysqlDB.DefaultGormDB().Model(&Register{}).Where("register_ip=?", ip).Pluck("user_id", &userIDList).Error err := IPDB.Model(&Register{}).Where("register_ip=?", ip).Pluck("user_id", &userIDList).Error
return userIDList, err return userIDList, err
} }
func InsertIpRecord(userID, createIp string) error { func InsertIpRecord(userID, createIp string) error {
record := &UserIpRecord{UserID: userID, CreateIp: createIp, LastLoginTime: time.Now(), LoginTimes: 1} record := &UserIpRecord{UserID: userID, CreateIp: createIp, LastLoginTime: time.Now(), LoginTimes: 1}
err := db.DB.MysqlDB.DefaultGormDB().Model(&UserIpRecord{}).Create(record).Error err := IPDB.Model(&UserIpRecord{}).Create(record).Error
return err return err
} }
func UpdateIpReocord(userID, ip string) (err error) { func UpdateIpReocord(userID, ip string) (err error) {
record := &UserIpRecord{UserID: userID, LastLoginIp: ip, LastLoginTime: time.Now()} record := &UserIpRecord{UserID: userID, LastLoginIp: ip, LastLoginTime: time.Now()}
result := db.DB.MysqlDB.DefaultGormDB().Model(&UserIpRecord{}).Where("user_id=?", userID).Updates(record).Update("login_times", gorm.Expr("login_times+?", 1)) result := IPDB.Model(&UserIpRecord{}).Where("user_id=?", userID).Updates(record).Update("login_times", gorm.Expr("login_times+?", 1))
if result.Error != nil { if result.Error != nil {
return utils.Wrap(result.Error, "") return utils.Wrap(result.Error, "")
} }

29
pkg/common/db/mysql_model/im_mysql_model/message_cms.go
Unescape View File

@ -2,12 +2,37 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"fmt" "fmt"
"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 GetChatLog(chatLog *ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []ChatLog, error) { func GetChatLog(chatLog *ChatLog, pageNumber, showNumber int32, contentTypeList []int32) (int64, []ChatLog, error) {
mdb := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs") mdb := ChatLogDB.Table("chat_logs")
if chatLog.SendTime.Unix() > 0 { if chatLog.SendTime.Unix() > 0 {
mdb = mdb.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1)) mdb = mdb.Where("send_time > ? and send_time < ?", chatLog.SendTime, chatLog.SendTime.AddDate(0, 0, 1))
} }

248
pkg/common/db/mysql_model/im_mysql_model/model_struct.go
Unescape View File

@ -4,23 +4,23 @@ import (
"time" "time"
) )
type Register struct { //type Register struct {
Account string `gorm:"column:account;primary_key;type:char(255)" json:"account"` // Account string `gorm:"column:account;primary_key;type:char(255)" json:"account"`
Password string `gorm:"column:password;type:varchar(255)" json:"password"` // Password string `gorm:"column:password;type:varchar(255)" json:"password"`
Ex string `gorm:"column:ex;size:1024" json:"ex"` // Ex string `gorm:"column:ex;size:1024" json:"ex"`
UserID string `gorm:"column:user_id;type:varchar(255)" json:"userID"` // UserID string `gorm:"column:user_id;type:varchar(255)" json:"userID"`
AreaCode string `gorm:"column:area_code;type:varchar(255)"` // AreaCode string `gorm:"column:area_code;type:varchar(255)"`
InvitationCode string `gorm:"column:invitation_code;type:varchar(255)"` // InvitationCode string `gorm:"column:invitation_code;type:varchar(255)"`
RegisterIP string `gorm:"column:register_ip;type:varchar(255)"` // RegisterIP string `gorm:"column:register_ip;type:varchar(255)"`
} //}
type Invitation struct { //type Invitation struct {
InvitationCode string `gorm:"column:invitation_code;primary_key;type:varchar(32)"` // InvitationCode string `gorm:"column:invitation_code;primary_key;type:varchar(32)"`
CreateTime time.Time `gorm:"column:create_time"` // CreateTime time.Time `gorm:"column:create_time"`
UserID string `gorm:"column:user_id;index:userID"` // UserID string `gorm:"column:user_id;index:userID"`
LastTime time.Time `gorm:"column:last_time"` // LastTime time.Time `gorm:"column:last_time"`
Status int32 `gorm:"column:status"` // Status int32 `gorm:"column:status"`
} //}
// message FriendInfo{ // message FriendInfo{
// string OwnerUserID = 1; // string OwnerUserID = 1;
@ -54,21 +54,21 @@ type Invitation struct {
// string Ex = 9; // string Ex = 9;
// } // }
// open_im_sdk.FriendRequest(nickname, farce url ...) != imdb.FriendRequest // open_im_sdk.FriendRequest(nickname, farce url ...) != imdb.FriendRequest
type FriendRequest struct { //type FriendRequest struct {
FromUserID string `gorm:"column:from_user_id;primary_key;size:64"` // FromUserID string `gorm:"column:from_user_id;primary_key;size:64"`
ToUserID string `gorm:"column:to_user_id;primary_key;size:64"` // ToUserID string `gorm:"column:to_user_id;primary_key;size:64"`
HandleResult int32 `gorm:"column:handle_result"` // HandleResult int32 `gorm:"column:handle_result"`
ReqMsg string `gorm:"column:req_msg;size:255"` // ReqMsg string `gorm:"column:req_msg;size:255"`
CreateTime time.Time `gorm:"column:create_time"` // CreateTime time.Time `gorm:"column:create_time"`
HandlerUserID string `gorm:"column:handler_user_id;size:64"` // HandlerUserID string `gorm:"column:handler_user_id;size:64"`
HandleMsg string `gorm:"column:handle_msg;size:255"` // HandleMsg string `gorm:"column:handle_msg;size:255"`
HandleTime time.Time `gorm:"column:handle_time"` // HandleTime time.Time `gorm:"column:handle_time"`
Ex string `gorm:"column:ex;size:1024"` // Ex string `gorm:"column:ex;size:1024"`
} //}
//
func (FriendRequest) TableName() string { //func (FriendRequest) TableName() string {
return "friend_requests" // return "friend_requests"
} //}
// message GroupInfo{ // message GroupInfo{
// string GroupID = 1; // string GroupID = 1;
@ -170,45 +170,45 @@ func (FriendRequest) TableName() string {
// int64 CreateTime = 10; // int64 CreateTime = 10;
// int32 AppMangerLevel = 11; // int32 AppMangerLevel = 11;
// open_im_sdk.User == imdb.User // open_im_sdk.User == imdb.User
type User struct { //type User struct {
UserID string `gorm:"column:user_id;primary_key;size:64"` // UserID string `gorm:"column:user_id;primary_key;size:64"`
Nickname string `gorm:"column:name;size:255"` // Nickname string `gorm:"column:name;size:255"`
FaceURL string `gorm:"column:face_url;size:255"` // FaceURL string `gorm:"column:face_url;size:255"`
Gender int32 `gorm:"column:gender"` // Gender int32 `gorm:"column:gender"`
PhoneNumber string `gorm:"column:phone_number;size:32"` // PhoneNumber string `gorm:"column:phone_number;size:32"`
Birth time.Time `gorm:"column:birth"` // Birth time.Time `gorm:"column:birth"`
Email string `gorm:"column:email;size:64"` // Email string `gorm:"column:email;size:64"`
Ex string `gorm:"column:ex;size:1024"` // Ex string `gorm:"column:ex;size:1024"`
CreateTime time.Time `gorm:"column:create_time;index:create_time"` // CreateTime time.Time `gorm:"column:create_time;index:create_time"`
AppMangerLevel int32 `gorm:"column:app_manger_level"` // AppMangerLevel int32 `gorm:"column:app_manger_level"`
GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"` // GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"`
//
status int32 `gorm:"column:status"` // 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 UserIpRecord struct {
type UserIpLimit struct { // UserID string `gorm:"column:user_id;primary_key;size:64"`
UserID string `gorm:"column:user_id;primary_key;size:64"` // CreateIp string `gorm:"column:create_ip;size:15"`
Ip string `gorm:"column:ip;primary_key;size:15"` // LastLoginTime time.Time `gorm:"column:last_login_time"`
CreateTime time.Time `gorm:"column:create_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{ // message BlackInfo{
// string OwnerUserID = 1; // string OwnerUserID = 1;
@ -219,64 +219,64 @@ type UserIpLimit struct {
// string Ex = 7; // string Ex = 7;
// } // }
// open_im_sdk.BlackInfo(BlackUserInfo) != imdb.Black (BlockUserID) // open_im_sdk.BlackInfo(BlackUserInfo) != imdb.Black (BlockUserID)
type Black struct { //type Black struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"` // OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"` // BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"`
CreateTime time.Time `gorm:"column:create_time"` // CreateTime time.Time `gorm:"column:create_time"`
AddSource int32 `gorm:"column:add_source"` // AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"` // OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"` // 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 { //type ChatLog struct {
return "chat_logs" // 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 { //type BlackList struct {
UserId string `gorm:"column:uid"` // UserId string `gorm:"column:uid"`
BeginDisableTime time.Time `gorm:"column:begin_disable_time"` // BeginDisableTime time.Time `gorm:"column:begin_disable_time"`
EndDisableTime time.Time `gorm:"column:end_disable_time"` // EndDisableTime time.Time `gorm:"column:end_disable_time"`
} //}
type Conversation struct { //type Conversation struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;type:char(128)" json:"OwnerUserID"` // 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"` // ConversationID string `gorm:"column:conversation_id;primary_key;type:char(128)" json:"conversationID"`
ConversationType int32 `gorm:"column:conversation_type" json:"conversationType"` // ConversationType int32 `gorm:"column:conversation_type" json:"conversationType"`
UserID string `gorm:"column:user_id;type:char(64)" json:"userID"` // UserID string `gorm:"column:user_id;type:char(64)" json:"userID"`
GroupID string `gorm:"column:group_id;type:char(128)" json:"groupID"` // GroupID string `gorm:"column:group_id;type:char(128)" json:"groupID"`
RecvMsgOpt int32 `gorm:"column:recv_msg_opt" json:"recvMsgOpt"` // RecvMsgOpt int32 `gorm:"column:recv_msg_opt" json:"recvMsgOpt"`
UnreadCount int32 `gorm:"column:unread_count" json:"unreadCount"` // UnreadCount int32 `gorm:"column:unread_count" json:"unreadCount"`
DraftTextTime int64 `gorm:"column:draft_text_time" json:"draftTextTime"` // DraftTextTime int64 `gorm:"column:draft_text_time" json:"draftTextTime"`
IsPinned bool `gorm:"column:is_pinned" json:"isPinned"` // IsPinned bool `gorm:"column:is_pinned" json:"isPinned"`
IsPrivateChat bool `gorm:"column:is_private_chat" json:"isPrivateChat"` // IsPrivateChat bool `gorm:"column:is_private_chat" json:"isPrivateChat"`
BurnDuration int32 `gorm:"column:burn_duration;default:30" json:"burnDuration"` // BurnDuration int32 `gorm:"column:burn_duration;default:30" json:"burnDuration"`
GroupAtType int32 `gorm:"column:group_at_type" json:"groupAtType"` // GroupAtType int32 `gorm:"column:group_at_type" json:"groupAtType"`
IsNotInGroup bool `gorm:"column:is_not_in_group" json:"isNotInGroup"` // IsNotInGroup bool `gorm:"column:is_not_in_group" json:"isNotInGroup"`
UpdateUnreadCountTime int64 `gorm:"column:update_unread_count_time" json:"updateUnreadCountTime"` // UpdateUnreadCountTime int64 `gorm:"column:update_unread_count_time" json:"updateUnreadCountTime"`
AttachedInfo string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"` // AttachedInfo string `gorm:"column:attached_info;type:varchar(1024)" json:"attachedInfo"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"` // Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
} //}
func (Conversation) TableName() string { //func (Conversation) TableName() string {
return "conversations" // return "conversations"
} //}
type Department struct { type Department struct {
DepartmentID string `gorm:"column:department_id;primary_key;size:64" json:"departmentID"` DepartmentID string `gorm:"column:department_id;primary_key;size:64" json:"departmentID"`

65
pkg/common/db/mysql_model/im_mysql_model/organization_model.go
Unescape View File

@ -1,29 +1,30 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"gorm.io/gorm" "gorm.io/gorm"
"time" "time"
) )
var OrgDB *gorm.DB
func CreateDepartment(department *Department) error { func CreateDepartment(department *Department) error {
department.CreateTime = time.Now() department.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Table("departments").Create(department).Error return OrgDB.Table("departments").Create(department).Error
} }
func GetDepartment(departmentID string) (*Department, error) { func GetDepartment(departmentID string) (*Department, error) {
var department Department var department Department
err := db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("department_id=?", departmentID).Find(&department).Error err := OrgDB.Table("departments").Where("department_id=?", departmentID).Find(&department).Error
return &department, err return &department, err
} }
func UpdateDepartment(department *Department, args map[string]interface{}) error { func UpdateDepartment(department *Department, args map[string]interface{}) error {
if err := db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("department_id=?", department.DepartmentID).Updates(department).Error; err != nil { if err := OrgDB.Table("departments").Where("department_id=?", department.DepartmentID).Updates(department).Error; err != nil {
return err return err
} }
if args != nil { if args != nil {
return db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("department_id=?", department.DepartmentID).Updates(args).Error return OrgDB.Table("departments").Where("department_id=?", department.DepartmentID).Updates(args).Error
} }
return nil return nil
} }
@ -32,9 +33,9 @@ func GetSubDepartmentList(departmentID string) ([]Department, error) {
var departmentList []Department var departmentList []Department
var err error var err error
if departmentID == "-1" { if departmentID == "-1" {
err = db.DB.MysqlDB.DefaultGormDB().Table("departments").Find(&departmentList).Error err = OrgDB.Table("departments").Find(&departmentList).Error
} else { } else {
err = db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("parent_id=?", departmentID).Find(&departmentList).Error err = OrgDB.Table("departments").Where("parent_id=?", departmentID).Find(&departmentList).Error
} }
return departmentList, err return departmentList, err
@ -42,10 +43,10 @@ func GetSubDepartmentList(departmentID string) ([]Department, error) {
func DeleteDepartment(departmentID string) error { func DeleteDepartment(departmentID string) error {
var err error var err error
if err = db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("department_id=?", departmentID).Delete(Department{}).Error; err != nil { if err = OrgDB.Table("departments").Where("department_id=?", departmentID).Delete(Department{}).Error; err != nil {
return err return err
} }
if err = db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=?", departmentID).Delete(DepartmentMember{}).Error; err != nil { if err = OrgDB.Table("department_members").Where("department_id=?", departmentID).Delete(DepartmentMember{}).Error; err != nil {
return err return err
} }
return nil return nil
@ -53,72 +54,72 @@ func DeleteDepartment(departmentID string) error {
func CreateOrganizationUser(organizationUser *OrganizationUser) error { func CreateOrganizationUser(organizationUser *OrganizationUser) error {
organizationUser.CreateTime = time.Now() organizationUser.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Create(organizationUser).Error return OrgDB.Table("organization_users").Create(organizationUser).Error
} }
func GetOrganizationUser(userID string) (error, *OrganizationUser) { func GetOrganizationUser(userID string) (error, *OrganizationUser) {
organizationUser := OrganizationUser{} organizationUser := OrganizationUser{}
err := db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Where("user_id=?", userID).Take(&organizationUser).Error err := OrgDB.Table("organization_users").Where("user_id=?", userID).Take(&organizationUser).Error
return err, &organizationUser return err, &organizationUser
} }
func GetOrganizationUsers(userIDList []string) ([]*OrganizationUser, error) { func GetOrganizationUsers(userIDList []string) ([]*OrganizationUser, error) {
var organizationUserList []*OrganizationUser var organizationUserList []*OrganizationUser
err := db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Where("user_id in (?)", userIDList).Find(&organizationUserList).Error err := OrgDB.Table("organization_users").Where("user_id in (?)", userIDList).Find(&organizationUserList).Error
return organizationUserList, err return organizationUserList, err
} }
func UpdateOrganizationUser(organizationUser *OrganizationUser, args map[string]interface{}) error { func UpdateOrganizationUser(organizationUser *OrganizationUser, args map[string]interface{}) error {
if err := db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(organizationUser).Error; err != nil { if err := OrgDB.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(organizationUser).Error; err != nil {
return err return err
} }
if args != nil { if args != nil {
return db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(args).Error return OrgDB.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(args).Error
} }
return nil return nil
} }
func CreateDepartmentMember(departmentMember *DepartmentMember) error { func CreateDepartmentMember(departmentMember *DepartmentMember) error {
departmentMember.CreateTime = time.Now() departmentMember.CreateTime = time.Now()
return db.DB.MysqlDB.DefaultGormDB().Table("department_members").Create(departmentMember).Error return OrgDB.Table("department_members").Create(departmentMember).Error
} }
func GetUserInDepartment(userID string) (error, []DepartmentMember) { func GetUserInDepartment(userID string) (error, []DepartmentMember) {
var departmentMemberList []DepartmentMember var departmentMemberList []DepartmentMember
err := db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("user_id=?", userID).Find(&departmentMemberList).Error err := OrgDB.Where("user_id=?", userID).Find(&departmentMemberList).Error
return err, departmentMemberList return err, departmentMemberList
} }
func UpdateUserInDepartment(departmentMember *DepartmentMember, args map[string]interface{}) error { func UpdateUserInDepartment(departmentMember *DepartmentMember, args map[string]interface{}) error {
if err := db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID). if err := OrgDB.Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
Updates(departmentMember).Error; err != nil { Updates(departmentMember).Error; err != nil {
return err return err
} }
if args != nil { if args != nil {
return db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID). return OrgDB.Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
Updates(args).Error Updates(args).Error
} }
return nil return nil
} }
func DeleteUserInDepartment(departmentID, userID string) error { func DeleteUserInDepartment(departmentID, userID string) error {
return db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=? AND user_id=?", departmentID, userID).Delete(DepartmentMember{}).Error return OrgDB.Table("department_members").Where("department_id=? AND user_id=?", departmentID, userID).Delete(DepartmentMember{}).Error
} }
func DeleteUserInAllDepartment(userID string) error { func DeleteUserInAllDepartment(userID string) error {
return db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("user_id=?", userID).Delete(DepartmentMember{}).Error return OrgDB.Table("department_members").Where("user_id=?", userID).Delete(DepartmentMember{}).Error
} }
func DeleteOrganizationUser(OrganizationUserID string) error { func DeleteOrganizationUser(OrganizationUserID string) error {
if err := DeleteUserInAllDepartment(OrganizationUserID); err != nil { if err := DeleteUserInAllDepartment(OrganizationUserID); err != nil {
return err return err
} }
return db.DB.MysqlDB.DefaultGormDB().Table("organization_users").Where("user_id=?", OrganizationUserID).Delete(OrganizationUser{}).Error return OrgDB.Table("organization_users").Where("user_id=?", OrganizationUserID).Delete(OrganizationUser{}).Error
} }
func GetDepartmentMemberUserIDList(departmentID string) (error, []string) { func GetDepartmentMemberUserIDList(departmentID string) (error, []string) {
var departmentMemberList []DepartmentMember var departmentMemberList []DepartmentMember
err := db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=?", departmentID).Take(&departmentMemberList).Error err := OrgDB.Table("department_members").Where("department_id=?", departmentID).Take(&departmentMemberList).Error
if err != nil { if err != nil {
return err, nil return err, nil
} }
@ -133,9 +134,9 @@ func GetDepartmentMemberList(departmentID string) ([]DepartmentMember, error) {
var departmentMemberList []DepartmentMember var departmentMemberList []DepartmentMember
var err error var err error
if departmentID == "-1" { if departmentID == "-1" {
err = db.DB.MysqlDB.DefaultGormDB().Table("department_members").Find(&departmentMemberList).Error err = OrgDB.Table("department_members").Find(&departmentMemberList).Error
} else { } else {
err = db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=?", departmentID).Find(&departmentMemberList).Error err = OrgDB.Table("department_members").Where("department_id=?", departmentID).Find(&departmentMemberList).Error
} }
if err != nil { if err != nil {
@ -147,12 +148,12 @@ func GetDepartmentMemberList(departmentID string) ([]DepartmentMember, error) {
func GetAllOrganizationUserID() (error, []string) { func GetAllOrganizationUserID() (error, []string) {
var OrganizationUser OrganizationUser var OrganizationUser OrganizationUser
var result []string var result []string
return db.DB.MysqlDB.DefaultGormDB().Model(&OrganizationUser).Pluck("user_id", &result).Error, result return OrgDB.Model(&OrganizationUser).Pluck("user_id", &result).Error, result
} }
func GetDepartmentMemberNum(departmentID string) (error, uint32) { func GetDepartmentMemberNum(departmentID string) (error, uint32) {
var number int64 var number int64
err := db.DB.MysqlDB.DefaultGormDB().Table("department_members").Where("department_id=?", departmentID).Count(&number).Error err := OrgDB.Table("department_members").Where("department_id=?", departmentID).Count(&number).Error
if err != nil { if err != nil {
return utils.Wrap(err, ""), 0 return utils.Wrap(err, ""), 0
} }
@ -162,7 +163,7 @@ func GetDepartmentMemberNum(departmentID string) (error, uint32) {
func GetSubDepartmentNum(departmentID string) (error, uint32) { func GetSubDepartmentNum(departmentID string) (error, uint32) {
var number int64 var number int64
err := db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("parent_id=?", departmentID).Count(&number).Error err := OrgDB.Table("departments").Where("parent_id=?", departmentID).Count(&number).Error
if err != nil { if err != nil {
return utils.Wrap(err, ""), 0 return utils.Wrap(err, ""), 0
} }
@ -171,12 +172,12 @@ func GetSubDepartmentNum(departmentID string) (error, uint32) {
func SetDepartmentRelatedGroupID(groupID, departmentID string) error { func SetDepartmentRelatedGroupID(groupID, departmentID string) error {
department := &Department{RelatedGroupID: groupID} department := &Department{RelatedGroupID: groupID}
return db.DB.MysqlDB.DefaultGormDB().Model(&department).Where("department_id=?", departmentID).Updates(department).Error return OrgDB.Model(&department).Where("department_id=?", departmentID).Updates(department).Error
} }
func GetDepartmentRelatedGroupIDList(departmentIDList []string) ([]string, error) { func GetDepartmentRelatedGroupIDList(departmentIDList []string) ([]string, error) {
var groupIDList []string var groupIDList []string
err := db.DB.MysqlDB.DefaultGormDB().Table("departments").Where("department_id IN (?) ", departmentIDList).Pluck("related_group_id", &groupIDList).Error err := OrgDB.Table("departments").Where("department_id IN (?) ", departmentIDList).Pluck("related_group_id", &groupIDList).Error
return groupIDList, err return groupIDList, err
} }
@ -184,7 +185,7 @@ func getDepartmentParent(departmentID string, dbConn *gorm.DB) (*Department, err
var department Department var department Department
var parentDepartment Department var parentDepartment Department
//var parentID string //var parentID string
err := db.DB.MysqlDB.DefaultGormDB().Model(&department).Where("department_id=?", departmentID).Select("parent_id").First(&department).Error err := OrgDB.Model(&department).Where("department_id=?", departmentID).Select("parent_id").First(&department).Error
if err != nil { if err != nil {
return nil, utils.Wrap(err, "") return nil, utils.Wrap(err, "")
} }
@ -210,7 +211,7 @@ func GetDepartmentParent(departmentID string, dbConn *gorm.DB, parentIDList *[]s
} }
func GetDepartmentParentIDList(departmentID string) ([]string, error) { func GetDepartmentParentIDList(departmentID string) ([]string, error) {
dbConn := db.DB.MysqlDB.DefaultGormDB() dbConn := OrgDB
var parentIDList []string var parentIDList []string
err := GetDepartmentParent(departmentID, dbConn, &parentIDList) err := GetDepartmentParent(departmentID, dbConn, &parentIDList)
return parentIDList, err return parentIDList, err
@ -218,6 +219,6 @@ func GetDepartmentParentIDList(departmentID string) ([]string, error) {
func GetRandomDepartmentID() (string, error) { func GetRandomDepartmentID() (string, error) {
department := &Department{} department := &Department{}
err := db.DB.MysqlDB.DefaultGormDB().Model(department).Order("RAND()").Where("related_group_id != ? AND department_id != ? AND department_type = ?", "", "0", 1).First(department).Error err := OrgDB.Model(department).Order("RAND()").Where("related_group_id != ? AND department_id != ? AND department_type = ?", "", "0", 1).First(department).Error
return department.DepartmentID, err return department.DepartmentID, err
} }

27
pkg/common/db/mysql_model/im_mysql_model/statistics_model.go
Unescape View File

@ -2,61 +2,60 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"time" "time"
) )
func GetActiveUserNum(from, to time.Time) (int32, error) { func GetActiveUserNum(from, to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Select("count(distinct(send_id))").Where("send_time >= ? and send_time <= ?", from, to).Count(&num).Error 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 return int32(num), err
} }
func GetIncreaseUserNum(from, to time.Time) (int32, error) { func GetIncreaseUserNum(from, to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error err := UserDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetTotalUserNum() (int32, error) { func GetTotalUserNum() (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Count(&num).Error err := UserDB.Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetTotalUserNumByDate(to time.Time) (int32, error) { func GetTotalUserNumByDate(to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("create_time <= ?", to).Count(&num).Error err := UserDB.Where("create_time <= ?", to).Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetPrivateMessageNum(from, to time.Time) (int32, error) { func GetPrivateMessageNum(from, to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 1).Count(&num).Error err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 1).Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetGroupMessageNum(from, to time.Time) (int32, error) { func GetGroupMessageNum(from, to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 2).Count(&num).Error err := ChatLogDB.Where("send_time >= ? and send_time <= ? and session_type = ?", from, to, 2).Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetIncreaseGroupNum(from, to time.Time) (int32, error) { func GetIncreaseGroupNum(from, to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error err := GroupDB.Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetTotalGroupNum() (int32, error) { func GetTotalGroupNum() (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Count(&num).Error err := GroupDB.Count(&num).Error
return int32(num), err return int32(num), err
} }
func GetGroupNum(to time.Time) (int32, error) { func GetGroupNum(to time.Time) (int32, error) {
var num int64 var num int64
err := db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("create_time <= ?", to).Count(&num).Error err := GroupDB.Where("create_time <= ?", to).Count(&num).Error
return int32(num), err return int32(num), err
} }
@ -68,12 +67,12 @@ type activeGroup struct {
func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) { func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) {
var activeGroups []*activeGroup var activeGroups []*activeGroup
err := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").Select("recv_id, count(*) as message_num").Where("send_time >= ? and send_time <= ? and session_type in (?)", from, to, []int{constant.GroupChatType, constant.SuperGroupChatType}).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error err := 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 { for _, activeGroup := range activeGroups {
group := Group{ group := Group{
GroupID: activeGroup.Id, GroupID: activeGroup.Id,
} }
db.DB.MysqlDB.DefaultGormDB().Table("groups").Where("group_id= ? ", group.GroupID).Find(&group) GroupDB.Where("group_id= ? ", group.GroupID).Find(&group)
activeGroup.Name = group.GroupName activeGroup.Name = group.GroupName
} }
return activeGroups, err return activeGroups, err
@ -87,12 +86,12 @@ type activeUser struct {
func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) { func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) {
var activeUsers []*activeUser var activeUsers []*activeUser
err := db.DB.MysqlDB.DefaultGormDB().Table("chat_logs").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 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 { for _, activeUser := range activeUsers {
user := User{ user := User{
UserID: activeUser.ID, UserID: activeUser.ID,
} }
err = db.DB.MysqlDB.DefaultGormDB().Table("users").Select("user_id, name").Find(&user).Error err = UserDB.Select("user_id, name").Find(&user).Error
if err != nil { if err != nil {
continue continue
} }

40
pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go
Unescape View File

@ -1,42 +1,44 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/db"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"gorm.io/gorm"
"time" "time"
) )
func InsertInToUserBlackList(ctx context.Context, black db.Black) (err error) { var BlackDB *gorm.DB
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"`
}
func InsertInToUserBlackList(ctx context.Context, black Black) (err error) {
defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "black", black) defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "black", black)
black.CreateTime = time.Now() black.CreateTime = time.Now()
err = db.DB.MysqlDB.DefaultGormDB().Table("blacks").Create(black).Error err = BlackDB.Create(black).Error
return err return err
} }
// type Black struct {
// OwnerUserID string `gorm:"column:owner_user_id;primaryKey;"`
// BlockUserID string `gorm:"column:block_user_id;primaryKey;"`
// CreateTime time.Time `gorm:"column:create_time"`
// AddSource int32 `gorm:"column:add_source"`
// OperatorUserID int32 `gorm:"column:operator_user_id"`
// Ex string `gorm:"column:ex"`
// }
func CheckBlack(ownerUserID, blockUserID string) error { func CheckBlack(ownerUserID, blockUserID string) error {
var black db.Black var black Black
return db.DB.MysqlDB.DefaultGormDB().Table("blacks").Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Find(&black).Error return BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Find(&black).Error
} }
func RemoveBlackList(ownerUserID, blockUserID string) error { func RemoveBlackList(ownerUserID, blockUserID string) error {
err := db.DB.MysqlDB.DefaultGormDB().Table("blacks").Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Delete(db.Black{}).Error err := BlackDB.Where("owner_user_id=? and block_user_id=?", ownerUserID, blockUserID).Delete(Black{}).Error
return utils.Wrap(err, "RemoveBlackList failed") return utils.Wrap(err, "RemoveBlackList failed")
} }
func GetBlackListByUserID(ownerUserID string) ([]db.Black, error) { func GetBlackListByUserID(ownerUserID string) ([]Black, error) {
var blackListUsersInfo []db.Black var blackListUsersInfo []Black
err := db.DB.MysqlDB.DefaultGormDB().Table("blacks").Where("owner_user_id=?", ownerUserID).Find(&blackListUsersInfo).Error err := BlackDB.Where("owner_user_id=?", ownerUserID).Find(&blackListUsersInfo).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -45,7 +47,7 @@ func GetBlackListByUserID(ownerUserID string) ([]db.Black, error) {
func GetBlackIDListByUserID(ownerUserID string) ([]string, error) { func GetBlackIDListByUserID(ownerUserID string) ([]string, error) {
var blackIDList []string var blackIDList []string
err := db.DB.MysqlDB.DefaultGormDB().Table("blacks").Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error err := BlackDB.Where("owner_user_id=?", ownerUserID).Pluck("block_user_id", &blackIDList).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }

83
pkg/common/db/mysql_model/im_mysql_model/user_model.go
Unescape View File

@ -3,13 +3,40 @@ package im_mysql_model
import ( import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"errors" "errors"
"fmt" "fmt"
"gorm.io/gorm"
"time" "time"
) )
var (
BlackListDB *gorm.DB
UserDB *gorm.DB
)
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 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 init() { func init() {
for k, v := range config.Config.Manager.AppManagerUid { for k, v := range config.Config.Manager.AppManagerUid {
_, err := GetUserByUserID(v) _, err := GetUserByUserID(v)
@ -42,7 +69,7 @@ func UserRegister(user User) error {
if user.Birth.Unix() < 0 { if user.Birth.Unix() < 0 {
user.Birth = utils.UnixSecondToTime(0) user.Birth = utils.UnixSecondToTime(0)
} }
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Create(&user).Error err := UserDB.Table("users").Create(&user).Error
if err != nil { if err != nil {
return err return err
} }
@ -51,13 +78,13 @@ func UserRegister(user User) error {
func GetAllUser() ([]User, error) { func GetAllUser() ([]User, error) {
var userList []User var userList []User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Find(&userList).Error err := UserDB.Table("users").Find(&userList).Error
return userList, err return userList, err
} }
func TakeUserByUserID(userID string) (*User, error) { func TakeUserByUserID(userID string) (*User, error) {
var user User var user User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id=?", userID).Take(&user).Error err := UserDB.Table("users").Where("user_id=?", userID).Take(&user).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -66,7 +93,7 @@ func TakeUserByUserID(userID string) (*User, error) {
func GetUserByUserID(userID string) (*User, error) { func GetUserByUserID(userID string) (*User, error) {
var user User var user User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id=?", userID).Take(&user).Error err := UserDB.Table("users").Where("user_id=?", userID).Take(&user).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -75,13 +102,13 @@ func GetUserByUserID(userID string) (*User, error) {
func GetUsersByUserIDList(userIDList []string) ([]*User, error) { func GetUsersByUserIDList(userIDList []string) ([]*User, error) {
var userList []*User var userList []*User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id in (?)", userIDList).Find(&userList).Error err := UserDB.Table("users").Where("user_id in (?)", userIDList).Find(&userList).Error
return userList, err return userList, err
} }
func GetUserNameByUserID(userID string) (string, error) { func GetUserNameByUserID(userID string) (string, error) {
var user User var user User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Select("name").Where("user_id=?", userID).First(&user).Error err := UserDB.Table("users").Select("name").Where("user_id=?", userID).First(&user).Error
if err != nil { if err != nil {
return "", err return "", err
} }
@ -89,17 +116,17 @@ func GetUserNameByUserID(userID string) (string, error) {
} }
func UpdateUserInfo(user User) error { func UpdateUserInfo(user User) error {
return db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id=?", user.UserID).Updates(&user).Error return UserDB.Where("user_id=?", user.UserID).Updates(&user).Error
} }
func UpdateUserInfoByMap(user User, m map[string]interface{}) error { func UpdateUserInfoByMap(user User, m map[string]interface{}) error {
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id=?", user.UserID).Updates(m).Error err := UserDB.Where("user_id=?", user.UserID).Updates(m).Error
return err return err
} }
func SelectAllUserID() ([]string, error) { func SelectAllUserID() ([]string, error) {
var resultArr []string var resultArr []string
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Pluck("user_id", &resultArr).Error err := UserDB.Pluck("user_id", &resultArr).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -108,7 +135,7 @@ func SelectAllUserID() ([]string, error) {
func SelectSomeUserID(userIDList []string) ([]string, error) { func SelectSomeUserID(userIDList []string) ([]string, error) {
var resultArr []string var resultArr []string
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id IN (?) ", userIDList).Pluck("user_id", &resultArr).Error err := UserDB.Pluck("user_id", &resultArr).Error
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -117,7 +144,7 @@ func SelectSomeUserID(userIDList []string) ([]string, error) {
func GetUsers(showNumber, pageNumber int32) ([]User, error) { func GetUsers(showNumber, pageNumber int32) ([]User, error) {
var users []User var users []User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error err := UserDB.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
if err != nil { if err != nil {
return users, err return users, err
} }
@ -140,13 +167,13 @@ func AddUser(userID string, phoneNumber string, name string, email string, gende
Ex: "", Ex: "",
CreateTime: time.Now(), CreateTime: time.Now(),
} }
result := db.DB.MysqlDB.DefaultGormDB().Table("users").Create(&user) result := UserDB.Create(&user)
return result.Error return result.Error
} }
func UserIsBlock(userId string) (bool, error) { func UserIsBlock(userId string) (bool, error) {
var user BlackList var user BlackList
rows := db.DB.MysqlDB.DefaultGormDB().Table("black_lists").Where("uid=?", userId).First(&user).RowsAffected rows := BlackListDB.Where("uid=?", userId).First(&user).RowsAffected
if rows >= 1 { if rows >= 1 {
return user.EndDisableTime.After(time.Now()), nil return user.EndDisableTime.After(time.Now()), nil
} }
@ -154,7 +181,7 @@ func UserIsBlock(userId string) (bool, error) {
} }
func UsersIsBlock(userIDList []string) (inBlockUserIDList []string, err error) { func UsersIsBlock(userIDList []string) (inBlockUserIDList []string, err error) {
err = db.DB.MysqlDB.DefaultGormDB().Table("black_lists").Where("uid in (?) and end_disable_time > now()", userIDList).Pluck("uid", &inBlockUserIDList).Error err = BlackListDB.Where("uid in (?) and end_disable_time > now()", userIDList).Pluck("uid", &inBlockUserIDList).Error
return inBlockUserIDList, err return inBlockUserIDList, err
} }
@ -171,9 +198,9 @@ func BlockUser(userID, endDisableTime string) error {
return errors.New("endDisableTime is before now") return errors.New("endDisableTime is before now")
} }
var blockUser BlackList var blockUser BlackList
db.DB.MysqlDB.DefaultGormDB().Table("black_lists").Where("uid=?", userID).First(&blockUser) BlackListDB.Where("uid=?", userID).First(&blockUser)
if blockUser.UserId != "" { if blockUser.UserId != "" {
db.DB.MysqlDB.DefaultGormDB().Model(&blockUser).Where("uid=?", blockUser.UserId).Update("end_disable_time", end) BlackListDB.Where("uid=?", blockUser.UserId).Update("end_disable_time", end)
return nil return nil
} }
blockUser = BlackList{ blockUser = BlackList{
@ -181,12 +208,12 @@ func BlockUser(userID, endDisableTime string) error {
BeginDisableTime: time.Now(), BeginDisableTime: time.Now(),
EndDisableTime: end, EndDisableTime: end,
} }
err = db.DB.MysqlDB.DefaultGormDB().Create(&blockUser).Error err = BlackListDB.Create(&blockUser).Error
return err return err
} }
func UnBlockUser(userID string) error { func UnBlockUser(userID string) error {
return db.DB.MysqlDB.DefaultGormDB().Where("uid=?", userID).Delete(&BlackList{}).Error return BlackListDB.Where("uid=?", userID).Delete(&BlackList{}).Error
} }
type BlockUserInfo struct { type BlockUserInfo struct {
@ -200,13 +227,13 @@ func GetBlockUserByID(userId string) (BlockUserInfo, error) {
blockUser := BlackList{ blockUser := BlackList{
UserId: userId, UserId: userId,
} }
if err := db.DB.MysqlDB.DefaultGormDB().Table("black_lists").Where("uid=?", userId).Find(&blockUser).Error; err != nil { if err := BlackListDB.Table("black_lists").Where("uid=?", userId).Find(&blockUser).Error; err != nil {
return blockUserInfo, err return blockUserInfo, err
} }
user := User{ user := User{
UserID: blockUser.UserId, UserID: blockUser.UserId,
} }
if err := db.DB.MysqlDB.DefaultGormDB().Find(&user).Error; err != nil { if err := BlackListDB.Find(&user).Error; err != nil {
return blockUserInfo, err return blockUserInfo, err
} }
blockUserInfo.User.UserID = user.UserID blockUserInfo.User.UserID = user.UserID
@ -224,12 +251,12 @@ func GetBlockUserByID(userId string) (BlockUserInfo, error) {
func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) { func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) {
var blockUserInfos []BlockUserInfo var blockUserInfos []BlockUserInfo
var blockUsers []BlackList var blockUsers []BlackList
if err := db.DB.MysqlDB.DefaultGormDB().Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&blockUsers).Error; err != nil { if err := BlackListDB.Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&blockUsers).Error; err != nil {
return blockUserInfos, err return blockUserInfos, err
} }
for _, blockUser := range blockUsers { for _, blockUser := range blockUsers {
var user User var user User
if err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where("user_id=?", blockUser.UserId).First(&user).Error; err == nil { if err := UserDB.Table("users").Where("user_id=?", blockUser.UserId).First(&user).Error; err == nil {
blockUserInfos = append(blockUserInfos, BlockUserInfo{ blockUserInfos = append(blockUserInfos, BlockUserInfo{
User: User{ User: User{
UserID: user.UserID, UserID: user.UserID,
@ -250,14 +277,14 @@ func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) {
func GetUserByName(userName string, showNumber, pageNumber int32) ([]User, error) { func GetUserByName(userName string, showNumber, pageNumber int32) ([]User, error) {
var users []User var users []User
err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error err := UserDB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
return users, err return users, err
} }
func GetUsersByNameAndID(content string, showNumber, pageNumber int32) ([]User, int64, error) { func GetUsersByNameAndID(content string, showNumber, pageNumber int32) ([]User, int64, error) {
var users []User var users []User
var count int64 var count int64
db := db.DB.MysqlDB.DefaultGormDB().Table("users").Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content) db := UserDB.Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content)
if err := db.Count(&count).Error; err != nil { if err := db.Count(&count).Error; err != nil {
return nil, 0, err return nil, 0, err
} }
@ -266,10 +293,10 @@ func GetUsersByNameAndID(content string, showNumber, pageNumber int32) ([]User,
} }
func GetUserIDsByEmailAndID(phoneNumber, email string) ([]string, error) { func GetUserIDsByEmailAndID(phoneNumber, email string) ([]string, error) {
db := db.DB.MysqlDB.DefaultGormDB().Table("users")
if phoneNumber == "" && email == "" { if phoneNumber == "" && email == "" {
return nil, nil return nil, nil
} }
db := UserDB
if phoneNumber != "" { if phoneNumber != "" {
db = db.Where("phone_number = ? ", phoneNumber) db = db.Where("phone_number = ? ", phoneNumber)
} }
@ -283,7 +310,7 @@ func GetUserIDsByEmailAndID(phoneNumber, email string) ([]string, error) {
func GetUsersCount(userName string) (int32, error) { func GetUsersCount(userName string) (int32, error) {
var count int64 var count int64
if err := db.DB.MysqlDB.DefaultGormDB().Table("users").Where(" name like ? ", fmt.Sprintf("%%%s%%", userName)).Count(&count).Error; err != nil { if err := UserDB.Where(" name like ? ", fmt.Sprintf("%%%s%%", userName)).Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return int32(count), nil return int32(count), nil
@ -291,7 +318,7 @@ func GetUsersCount(userName string) (int32, error) {
func GetBlockUsersNumCount() (int32, error) { func GetBlockUsersNumCount() (int32, error) {
var count int64 var count int64
if err := db.DB.MysqlDB.DefaultGormDB().Model(&BlackList{}).Count(&count).Error; err != nil { if err := BlackListDB.Count(&count).Error; err != nil {
return 0, err return 0, err
} }
return int32(count), nil return int32(count), nil

36
pkg/getcdv3/temp.go
Unescape View File

@ -1,7 +1,41 @@
package getcdv3 package getcdv3
import "google.golang.org/grpc" import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log"
"context"
"github.com/OpenIMSDK/getcdv3"
"google.golang.org/grpc"
"strings"
"sync"
)
func GetDefaultConn(arg1, arg2, arg3, arg4 string) *grpc.ClientConn { func GetDefaultConn(arg1, arg2, arg3, arg4 string) *grpc.ClientConn {
return nil return nil
} }
func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) {
defer func() {
trace_log.SetContextInfo(ctx, "GetConn", err, "serviceName", serviceName)
}()
conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","),
serviceName, trace_log.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)
if conn == nil {
return nil, constant.ErrRpcConn
}
return conn, nil
}
func GetDefaultGatewayConn4Unique(schema, addr, operationID string) []*grpc.ClientConn {
return nil
}
func RegisterEtcd(schema, etcdAddr, myHost string, myPort int, serviceName string, ttl int, operationID string) error {
return getcdv3.RegisterEtcd(schema, etcdAddr, myHost, myPort, serviceName, ttl, operationID)
}
var Conn4UniqueList []*grpc.ClientConn
var Conn4UniqueListMtx sync.RWMutex
var IsUpdateStart bool
var IsUpdateStartMtx sync.RWMutex

1
pkg/utils/cache_delete.go
Unescape View File

@ -1 +0,0 @@
package utils

15
pkg/utils/getcd.go
Unescape View File

@ -2,31 +2,16 @@ package utils
import ( import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log"
"context" "context"
"fmt" "fmt"
"github.com/OpenIMSDK/getcdv3" "github.com/OpenIMSDK/getcdv3"
clientv3 "go.etcd.io/etcd/client/v3" clientv3 "go.etcd.io/etcd/client/v3"
"time" "time"
"google.golang.org/grpc"
"gopkg.in/yaml.v3" "gopkg.in/yaml.v3"
"strings" "strings"
) )
func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) {
defer func() {
trace_log.SetContextInfo(ctx, "GetConn", err, "serviceName", serviceName)
}()
conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","),
serviceName, trace_log.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)
if conn == nil {
return nil, constant.ErrRpcConn
}
return conn, nil
}
func registerConf(key, conf string) { func registerConf(key, conf string) {
etcdAddr := strings.Join(config.Config.Etcd.EtcdAddr, ",") etcdAddr := strings.Join(config.Config.Etcd.EtcdAddr, ",")
cli, err := clientv3.New(clientv3.Config{ cli, err := clientv3.New(clientv3.Config{

Write Preview
Loading…
Cancel
Save