blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-08-06 19:20:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

Browse Source 
 Conflicts:
	pkg/common/db/relation/black.go
This commit is contained in:
wangchuxiao 2023-02-01 18:42:38 +08:00
commit 5bb731f884
12 changed files with 278 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
internal/common/convert/convert.go
View File

@ -1,7 +1,6 @@
package convert
import (
"Open_IM/pkg/common/db/relation"
"Open_IM/pkg/common/db/table"
sdk "Open_IM/pkg/proto/sdk_ws"
utils "github.com/OpenIMSDK/open_utils"
@ -23,8 +22,8 @@ type DBFriend struct {
*table.FriendModel
}
func NewDBFriend(friend *controller.Friend) *DBFriend {
return &DBFriend{Friend: friend}
func NewDBFriend(friend *table.FriendModel) *DBFriend {
return &DBFriend{FriendModel: friend}
}
type PBFriend struct {
@ -35,6 +34,14 @@ func NewPBFriend(friendInfo *sdk.FriendInfo) *PBFriend {
return &PBFriend{FriendInfo: friendInfo}
}
func (*PBFriend) PB2DB(friends []*sdk.FriendInfo) (DBFriends []*table.FriendModel, err error) {
}
func (*DBFriend) DB2PB(friends []*table.FriendModel) (PBFriends []*sdk.FriendInfo, err error) {
}
func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
utils.CopyStructFields(pbFriend, db)
@ -49,8 +56,8 @@ func (db *DBFriend) Convert() (*sdk.FriendInfo, error) {
return pbFriend, nil
}
func (pb *PBFriend) Convert() (*relation.Friend, error) {
dbFriend := &relation.Friend{}
func (pb *PBFriend) Convert() (*table.FriendModel, error) {
dbFriend := &table.FriendModel{}
utils.CopyStructFields(dbFriend, pb)
dbFriend.FriendUserID = pb.FriendUser.UserID
dbFriend.CreateTime = utils.UnixSecondToTime(pb.CreateTime)
@ -58,11 +65,11 @@ func (pb *PBFriend) Convert() (*relation.Friend, error) {
}
type DBFriendRequest struct {
*relation.FriendRequest
*table.FriendRequestModel
}
func NewDBFriendRequest(friendRequest *relation.FriendRequest) *DBFriendRequest {
return &DBFriendRequest{FriendRequest: friendRequest}
func NewDBFriendRequest(friendRequest *table.FriendRequestModel) *DBFriendRequest {
return &DBFriendRequest{FriendRequestModel: friendRequest}
}
type PBFriendRequest struct {
@ -73,8 +80,16 @@ func NewPBFriendRequest(friendRequest *sdk.FriendRequest) *PBFriendRequest {
return &PBFriendRequest{FriendRequest: friendRequest}
}
func (pb *PBFriendRequest) Convert() (*relation.FriendRequest, error) {
dbFriendRequest := &relation.FriendRequest{}
func (*PBFriendRequest) PB2DB(friendRequests []*sdk.FriendRequest) (DBFriendRequests []*table.FriendRequestModel, err error) {
}
func (*DBFriendRequest) DB2PB(friendRequests []*table.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) {
}
func (pb *PBFriendRequest) Convert() (*table.FriendRequestModel, error) {
dbFriendRequest := &table.FriendRequestModel{}
utils.CopyStructFields(dbFriendRequest, pb)
dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@ -103,11 +118,19 @@ func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) {
}
type DBBlack struct {
*relation.Black
*table.BlackModel
}
func NewDBBlack(black *relation.Black) *DBBlack {
return &DBBlack{Black: black}
func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*table.BlackModel, err error) {
}
func (*DBBlack) DB2PB(blacks []*table.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) {
}
func NewDBBlack(black *table.BlackModel) *DBBlack {
return &DBBlack{BlackModel: black}
}
type PBBlack struct {
@ -118,8 +141,8 @@ func NewPBBlack(blackInfo *sdk.BlackInfo) *PBBlack {
return &PBBlack{BlackInfo: blackInfo}
}
func (pb *PBBlack) Convert() (*relation.Black, error) {
dbBlack := &relation.Black{}
func (pb *PBBlack) Convert() (*table.BlackModel, error) {
dbBlack := &table.BlackModel{}
dbBlack.BlockUserID = pb.BlackUserInfo.UserID
dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
return dbBlack, nil
@ -137,11 +160,19 @@ func (db *DBBlack) Convert() (*sdk.BlackInfo, error) {
}
type DBGroup struct {
*relation.Group
*table.GroupModel
}
func NewDBGroup(group *relation.Group) *DBGroup {
return &DBGroup{Group: group}
func (*PBGroup) PB2DB(groups []*sdk.GroupInfo) (DBGroups []*table.GroupModel, err error) {
}
func (*DBGroup) DB2PB(groups []*table.GroupModel) (PBGroups []*sdk.GroupInfo, err error) {
}
func NewDBGroup(group *table.GroupModel) *DBGroup {
return &DBGroup{GroupModel: group}
}
type PBGroup struct {
@ -152,8 +183,8 @@ func NewPBGroup(groupInfo *sdk.GroupInfo) *PBGroup {
return &PBGroup{GroupInfo: groupInfo}
}
func (pb *PBGroup) Convert() *relation.Group {
dst := &relation.Group{}
func (pb *PBGroup) Convert() *table.GroupModel {
dst := &table.GroupModel{}
_ = utils.CopyStructFields(dst, pb)
return dst
}
@ -180,11 +211,19 @@ func (db *DBGroup) Convert() (*sdk.GroupInfo, error) {
}
type DBGroupMember struct {
*relation.GroupMember
*table.GroupMemberModel
}
func NewDBGroupMember(groupMember *relation.GroupMember) *DBGroupMember {
return &DBGroupMember{GroupMember: groupMember}
func (*PBGroupMember) PB2DB(groupMembers []*sdk.GroupMemberFullInfo) (DBGroupMembers []*table.GroupMemberModel, err error) {
}
func (*DBGroupMember) DB2PB(groupMembers []*table.GroupMemberModel) (PBGroupMembers []*sdk.GroupMemberFullInfo, err error) {
}
func NewDBGroupMember(groupMember *table.GroupMemberModel) *DBGroupMember {
return &DBGroupMember{GroupMemberModel: groupMember}
}
type PBGroupMember struct {
@ -195,8 +234,8 @@ func NewPBGroupMember(groupMemberFullInfo *sdk.GroupMemberFullInfo) *PBGroupMemb
return &PBGroupMember{GroupMemberFullInfo: groupMemberFullInfo}
}
func (pb *PBGroupMember) Convert() (*relation.GroupMember, error) {
dst := &relation.GroupMember{}
func (pb *PBGroupMember) Convert() (*table.GroupMemberModel, error) {
dst := &table.GroupMemberModel{}
utils.CopyStructFields(dst, pb)
dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
@ -224,11 +263,19 @@ func (db *DBGroupMember) Convert() (*sdk.GroupMemberFullInfo, error) {
}
type DBGroupRequest struct {
*relation.GroupRequest
*table.GroupRequestModel
}
func NewDBGroupRequest(groupRequest *relation.GroupRequest) *DBGroupRequest {
return &DBGroupRequest{GroupRequest: groupRequest}
func (*PBGroupRequest) PB2DB(groupRequests []*sdk.GroupRequest) (DBGroupRequests []*table.GroupRequestModel, err error) {
}
func (*DBGroupRequest) DB2PB(groupRequests []*table.GroupRequestModel) (PBGroupRequests []*sdk.GroupRequest, err error) {
}
func NewDBGroupRequest(groupRequest *table.GroupRequestModel) *DBGroupRequest {
return &DBGroupRequest{GroupRequestModel: groupRequest}
}
type PBGroupRequest struct {
@ -239,8 +286,8 @@ func NewPBGroupRequest(groupRequest *sdk.GroupRequest) *PBGroupRequest {
return &PBGroupRequest{GroupRequest: groupRequest}
}
func (pb *PBGroupRequest) Convert() (*relation.GroupRequest, error) {
dst := &relation.GroupRequest{}
func (pb *PBGroupRequest) Convert() (*table.GroupRequestModel, error) {
dst := &table.GroupRequestModel{}
utils.CopyStructFields(dst, pb)
dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
@ -255,11 +302,11 @@ func (db *DBGroupRequest) Convert() (*sdk.GroupRequest, error) {
}
type DBUser struct {
*relation.User
*table.UserModel
}
func NewDBUser(user *relation.User) *DBUser {
return &DBUser{User: user}
func NewDBUser(user *table.UserModel) *DBUser {
return &DBUser{UserModel: user}
}
type PBUser struct {
@ -270,7 +317,7 @@ func NewPBUser(userInfo *sdk.UserInfo) *PBUser {
return &PBUser{UserInfo: userInfo}
}
func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*relation.User, err error) {
func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*table.UserModel, err error) {
for _, v := range users {
u, err := NewPBUser(v).Convert()
if err != nil {
@ -281,7 +328,7 @@ func (*PBUser) PB2DB(users []*sdk.UserInfo) (DBUsers []*relation.User, err error
return
}
func (*DBUser) DB2PB(users []*relation.User) (PBUsers []*sdk.UserInfo, err error) {
func (*DBUser) DB2PB(users []*table.UserModel) (PBUsers []*sdk.UserInfo, err error) {
for _, v := range users {
u, err := NewDBUser(v).Convert()
if err != nil {
@ -292,8 +339,8 @@ func (*DBUser) DB2PB(users []*relation.User) (PBUsers []*sdk.UserInfo, err error
return
}
func (pb *PBUser) Convert() (*relation.User, error) {
dst := &relation.User{}
func (pb *PBUser) Convert() (*table.UserModel, error) {
dst := &table.UserModel{}
utils.CopyStructFields(dst, pb)
dst.Birth = utils.UnixSecondToTime(pb.Birthday)
dst.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))

24
internal/rpc/friend/black.go
View File

@ -4,7 +4,7 @@ import (
"Open_IM/internal/common/check"
"Open_IM/internal/common/convert"
chat "Open_IM/internal/rpc/msg"
"Open_IM/pkg/common/db/relation"
"Open_IM/pkg/common/db/table"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/common/tracelog"
pbFriend "Open_IM/pkg/proto/friend"
@ -20,15 +20,11 @@ func (s *friendServer) GetBlacks(ctx context.Context, req *pbFriend.GetBlacksReq
if err != nil {
return nil, err
}
blackIDList := make([]string, 0, len(blacks))
for _, black := range blacks {
b, err := convert.NewDBBlack(black).Convert()
if err != nil {
return nil, err
}
resp.Blacks = append(resp.Blacks, b)
blackIDList = append(blackIDList, black.BlockUserID)
resp.Blacks, err = (*convert.DBBlack)(nil).DB2PB(blacks)
if err != nil {
return nil, err
}
resp.Total = int32(total)
return resp, nil
}
@ -49,10 +45,10 @@ func (s *friendServer) RemoveBlack(ctx context.Context, req *pbFriend.RemoveBlac
if err := check.Access(ctx, req.OwnerUserID); err != nil {
return nil, err
}
if err := s.BlackInterface.Delete(ctx, []*relation.Black{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
if err := s.BlackInterface.Delete(ctx, []*table.BlackModel{{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID}}); err != nil {
return nil, err
}
chat.BlackDeletedNotification(req)
chat.BlackDeletedNotification(ctx, req)
return resp, nil
}
@ -61,10 +57,10 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
return nil, err
}
black := relation.Black{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
if err := s.BlackInterface.Create(ctx, []*relation.Black{&black}); err != nil {
black := table.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx)}
if err := s.BlackInterface.Create(ctx, []*table.BlackModel{&black}); err != nil {
return nil, err
}
chat.BlackAddedNotification(tracelog.GetOperationID(ctx), req)
chat.BlackAddedNotification(ctx, req)
return resp, nil
}

1
internal/rpc/group/copy.go Normal file
View File

@ -0,0 +1 @@
package group

124
internal/rpc/group/group.go
View File

@ -191,8 +191,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
if err := callbackBeforeCreateGroup(ctx, req); err != nil {
return nil, err
}
var group relation.GroupGorm
var groupMembers []*relation.GroupMember
var group table.GroupModel
var groupMembers []*table.GroupMemberModel
utils.CopyStructFields(&group, req.GroupInfo)
group.GroupID = genGroupID(ctx, req.GroupInfo.GroupID)
if req.GroupInfo.GroupType == constant.SuperGroup {
@ -202,7 +202,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
} else {
joinGroup := func(userID string, roleLevel int32) error {
user := userMap[userID]
groupMember := &relation.GroupMember{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
groupMember := &table.GroupMemberModel{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
utils.CopyStructFields(&groupMember, user)
if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
return err
@ -224,7 +224,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
}
}
}
if err := s.GroupInterface.CreateGroup(ctx, []*relation.GroupGorm{&group}, groupMembers); err != nil {
if err := s.GroupInterface.CreateGroup(ctx, []*table.GroupModel{&group}, groupMembers); err != nil {
return nil, err
}
utils.CopyStructFields(resp.GroupInfo, group)
@ -300,7 +300,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
if err != nil {
return nil, err
}
memberMap := make(map[string]*relation.GroupMember)
memberMap := make(map[string]*table.GroupMemberModel)
for i, member := range members {
memberMap[member.GroupID] = members[i]
}
@ -326,9 +326,9 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
return nil, constant.ErrNoPermission.Wrap("not in group")
}
if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
var requests []*relation.GroupRequest
var requests []*table.GroupRequestModel
for _, userID := range req.InvitedUserIDs {
requests = append(requests, &relation.GroupRequest{
requests = append(requests, &table.GroupRequestModel{
UserID: userID,
GroupID: req.GroupID,
JoinSource: constant.JoinByInvitation,
@ -359,10 +359,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
}
} else {
opUserID := tracelog.GetOpUserID(ctx)
var groupMembers []*relation.GroupMember
var groupMembers []*table.GroupMemberModel
for _, userID := range req.InvitedUserIDs {
user := userMap[userID]
var member relation.GroupMember
var member table.GroupMemberModel
utils.CopyStructFields(&member, user)
member.GroupID = req.GroupID
member.RoleLevel = constant.GroupOrdinaryUsers
@ -420,25 +420,25 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGr
return resp, nil
}
func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) {
opFlag := 0
if !token_verify.IsManagerUserID(userID) {
opInfo, err := relation.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
if err != nil {
return opFlag, utils.Wrap(err, "")
}
if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
opFlag = 0
} else if opInfo.RoleLevel == constant.GroupOwner {
opFlag = 2 // owner
} else {
opFlag = 3 // admin
}
} else {
opFlag = 1 // app manager
}
return opFlag, nil
}
//func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) {
// opFlag := 0
// if !token_verify.IsManagerUserID(userID) {
// opInfo, err := relation.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
// if err != nil {
// return opFlag, utils.Wrap(err, "")
// }
// if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
// opFlag = 0
// } else if opInfo.RoleLevel == constant.GroupOwner {
// opFlag = 2 // owner
// } else {
// opFlag = 3 // admin
// }
// } else {
// opFlag = 1 // app manager
// }
// return opFlag, nil
//}
func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
resp := &pbGroup.KickGroupMemberResp{}
@ -470,7 +470,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
if err != nil {
return nil, err
}
memberMap := make(map[string]*relation.GroupMember)
memberMap := make(map[string]*table.GroupMemberModel)
for i, member := range members {
memberMap[member.UserID] = members[i]
}
@ -522,28 +522,28 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
return resp, nil
}
func FillGroupInfoByGroupID(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo) error {
group, err := relation.TakeGroupInfoByGroupID(groupID)
if err != nil {
log.Error(operationID, "TakeGroupInfoByGroupID failed ", err.Error(), groupID)
return utils.Wrap(err, "")
}
if group.Status == constant.GroupStatusDismissed {
log.Debug(operationID, " group constant.GroupStatusDismissed ", group.GroupID)
return utils.Wrap(constant.ErrDismissedAlready, "")
}
return utils.Wrap(cp.GroupDBCopyOpenIM(groupInfo, group), "")
}
//func FillGroupInfoByGroupID(operationID, groupID string, groupInfo *open_im_sdk.GroupInfo) error {
// group, err := relation.TakeGroupInfoByGroupID(groupID)
// if err != nil {
// log.Error(operationID, "TakeGroupInfoByGroupID failed ", err.Error(), groupID)
// return utils.Wrap(err, "")
// }
// if group.Status == constant.GroupStatusDismissed {
// log.Debug(operationID, " group constant.GroupStatusDismissed ", group.GroupID)
// return utils.Wrap(constant.ErrDismissedAlready, "")
// }
// return utils.Wrap(cp.GroupDBCopyOpenIM(groupInfo, group), "")
//}
func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sdk.PublicUserInfo) error {
user, err := relation.TakeUserByUserID(userID)
if err != nil {
log.Error(operationID, "TakeUserByUserID failed ", err.Error(), userID)
return utils.Wrap(err, "")
}
cp.UserDBCopyOpenIMPublicUser(userInfo, user)
return nil
}
//func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sdk.PublicUserInfo) error {
// user, err := relation.TakeUserByUserID(userID)
// if err != nil {
// log.Error(operationID, "TakeUserByUserID failed ", err.Error(), userID)
// return utils.Wrap(err, "")
// }
// cp.UserDBCopyOpenIMPublicUser(userInfo, user)
// return nil
//}
func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) {
resp := &pbGroup.GetGroupApplicationListResp{}
@ -575,7 +575,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
if err != nil {
return nil, err
}
groupMap := make(map[string]*relation.GroupGorm)
groupMap := make(map[string]*table.GroupModel)
for i, group := range groups {
groupMap[group.GroupID] = groups[i]
}
@ -648,7 +648,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err
}
groupRequest := getDBGroupRequest(ctx, req)
if err := (&relation.GroupRequest{}).Update(ctx, []*relation.GroupRequest{groupRequest}); err != nil {
if err := (&table.GroupRequestModel{}).Update(ctx, []*table.GroupRequestModel{groupRequest}); err != nil {
return nil, err
}
groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
@ -664,7 +664,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
if err != nil {
return nil, err
}
err = (&relation.GroupMember{}).Create(ctx, []*relation.GroupMember{member})
err = (&table.GroupMemberModel{}).Create(ctx, []*table.GroupMemberModel{member})
if err != nil {
return nil, err
}
@ -718,7 +718,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return nil, err
}
//to group member
groupMember := relation.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
groupMember := table.GroupMemberModel{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
utils.CopyStructFields(&groupMember, us)
if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), &groupMember, groupInfo.Ex); err != nil {
return nil, err
@ -761,7 +761,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return resp, nil
}
}
var groupRequest relation.GroupRequest
var groupRequest table.GroupRequestModel
groupRequest.UserID = tracelog.GetOpUserID(ctx)
groupRequest.ReqMsg = req.ReqMessage
groupRequest.GroupID = req.GroupID
@ -872,7 +872,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
}
}
//only administrators can set group information
var groupInfo relation.GroupGorm
var groupInfo table.GroupModel
utils.CopyStructFields(&groupInfo, req.GroupInfoForSet)
if req.GroupInfoForSet.Notification != "" {
groupInfo.NotificationUserID = tracelog.GetOpUserID(ctx)
@ -932,12 +932,12 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
return nil, err
}
groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
err = relation.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
return nil, err
}
groupMemberInfo = relation.GroupMember{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
groupMemberInfo = table.GroupMemberModel{GroupID: req.GroupID, UserID: req.NewOwnerUserID, RoleLevel: constant.GroupOwner}
err = relation.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
return nil, err
@ -1131,7 +1131,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, req.UserID); err != nil {
return nil, err
}
groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo.MuteEndTime = time.Unix(int64(time.Now().Second())+int64(req.MutedSeconds), time.Now().UnixNano())
err = relation.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
@ -1166,7 +1166,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
return nil, err
}
groupMemberInfo := relation.GroupMember{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo := table.GroupMemberModel{GroupID: req.GroupID, UserID: req.UserID}
groupMemberInfo.MuteEndTime = time.Unix(0, 0)
err = relation.UpdateGroupMemberInfo(groupMemberInfo)
if err != nil {
@ -1265,7 +1265,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
return nil, err
}
nickName := cbReq.Nickname.Value
groupMemberInfo := relation.GroupMember{}
groupMemberInfo := table.GroupMemberModel{}
groupMemberInfo.UserID = req.UserID
groupMemberInfo.GroupID = req.GroupID
if nickName == "" {
@ -1298,7 +1298,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil {
return nil, err
}
groupMember := relation.GroupMember{
groupMember := table.GroupMemberModel{
GroupID: req.GroupID,
UserID: req.UserID,
}

13
internal/rpc/user/user.go
View File

@ -7,6 +7,7 @@ import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db/controller"
"Open_IM/pkg/common/db/relation"
"Open_IM/pkg/common/db/table"
"Open_IM/pkg/common/log"
promePkg "Open_IM/pkg/common/prometheus"
"Open_IM/pkg/common/token_verify"
@ -45,7 +46,7 @@ func NewUserServer(port int) *userServer {
}
//mysql init
var mysql relation.Mysql
var model relation.User
var model relation.UserGorm
err := mysql.InitConn().AutoMigrateModel(&model)
if err != nil {
panic("db init err:" + err.Error())
@ -197,7 +198,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
if err != nil {
return nil, err
}
err = s.Update(ctx, []*relation.User{user})
err = s.Update(ctx, []*table.UserModel{user})
if err != nil {
return nil, err
}
@ -213,11 +214,11 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
}
go func() {
for _, v := range rpcResp.FriendsInfo {
chat.FriendInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
chat.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v.FriendUser.UserID, tracelog.GetOpUserID(ctx))
}
}()
chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
chat.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
if req.UserInfo.FaceURL != "" {
s.SyncJoinedGroupMemberFaceURL(ctx, req.UserInfo.UserID, req.UserInfo.FaceURL, tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx))
}
@ -235,13 +236,13 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbUser.Se
if err != nil {
return nil, err
}
chat.UserInfoUpdatedNotification(tracelog.GetOperationID(ctx), req.UserID, req.UserID)
chat.UserInfoUpdatedNotification(ctx, req.UserID, req.UserID)
return &resp, nil
}
func (s *userServer) AccountCheck(ctx context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
resp := pbUser.AccountCheckResp{}
err := token_verify.CheckManagerUserID(ctx, tracelog.GetOpUserID(ctx))
err := token_verify.CheckAdmin(ctx)
if err != nil {
return nil, err
}

8
pkg/common/db/controller/black.go
View File

@ -1,7 +1,7 @@
package controller
import (
"Open_IM/pkg/common/db/relation"
"Open_IM/pkg/common/db/table"
"context"
"errors"
"gorm.io/gorm"
@ -9,11 +9,11 @@ import (
type BlackInterface interface {
// Create 增加黑名单
Create(ctx context.Context, blacks []*relation.Black) (err error)
Create(ctx context.Context, blacks []*table.BlackModel) (err error)
// Delete 删除黑名单
Delete(ctx context.Context, blacks []*relation.Black) (err error)
Delete(ctx context.Context, blacks []*table.BlackModel) (err error)
// FindOwnerBlacks 获取黑名单列表
FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*relation.Black, total int64, err error)
FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*table.BlackModel, total int64, err error)
// CheckIn 检查user2是否在user1的黑名单列表中(inUser1Blacks==true) 检查user1是否在user2的黑名单列表中(inUser2Blacks==true)
CheckIn(ctx context.Context, userID1, userID2 string) (inUser1Blacks bool, inUser2Blacks bool, err error)
}

10
pkg/common/db/controller/group.go
View File

@ -15,21 +15,21 @@ import (
type GroupInterface interface {
FindGroupsByID(ctx context.Context, groupIDs []string) (groups []*table.GroupModel, err error)
CreateGroup(ctx context.Context, groups []*table.GroupModel, groupMember []*table.GroupModel) error
CreateGroup(ctx context.Context, groups []*table.GroupModel, groupMember []*table.GroupMemberModel) error
DeleteGroupByIDs(ctx context.Context, groupIDs []string) error
TakeGroupByID(ctx context.Context, groupID string) (group *table.GroupModel, err error)
TakeGroupMemberByID(ctx context.Context, groupID string, userID string) (groupMember *table.GroupModel, err error)
GetJoinedGroupList(ctx context.Context, userID string) ([]*table.GroupModel, error)
GetGroupMemberList(ctx context.Context, groupID string) ([]*table.GroupModel, error)
GetGroupMemberListByUserID(ctx context.Context, groupID string, userIDs []string) ([]*table.GroupModel, error)
GetGroupMemberList(ctx context.Context, groupID string) ([]*table.GroupMemberModel, error)
GetGroupMemberListByUserID(ctx context.Context, groupID string, userIDs []string) ([]*table.GroupMemberModel, error)
GetGroupMemberFilterList(ctx context.Context, groupID string, filter int32, begin int32, maxNumber int32) ([]*table.GroupModel, error) // relation.GetGroupMemberByGroupID(req.GroupID, req.Filter, req.NextSeq, 30)
FindGroupMembersByID(ctx context.Context, groupID string, userIDs []string) (groups []*table.GroupModel, err error)
FindGroupMembersByID(ctx context.Context, groupID string, userIDs []string) (groups []*table.GroupMemberModel, err error)
DelGroupMember(ctx context.Context, groupID string, userIDs []string) error
GetGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]int, error)
GetGroupOwnerUserID(ctx context.Context, groupIDs []string) (map[string]string, error)
GetGroupRecvApplicationList(ctx context.Context, userID string) ([]*table.GroupRequestModel, error)
CreateGroupMember(ctx context.Context, groupMember []*table.GroupModel) error
CreateGroupMember(ctx context.Context, groupMember []*table.GroupMemberModel) error
CreateGroupRequest(ctx context.Context, requests []*table.GroupRequestModel) error
//mongo

59
pkg/common/db/controller/user.go
View File

@ -2,19 +2,20 @@ package controller
import (
"Open_IM/pkg/common/db/relation"
"Open_IM/pkg/common/db/table"
"context"
"gorm.io/gorm"
)
type UserInterface interface {
//获取指定用户的信息 如果有记录未找到 也返回错误
Find(ctx context.Context, userIDs []string) (users []*relation.User, err error)
Create(ctx context.Context, users []*relation.User) error
Update(ctx context.Context, users []*relation.User) (err error)
Find(ctx context.Context, userIDs []string) (users []*table.UserModel, err error)
Create(ctx context.Context, users []*table.UserModel) error
Update(ctx context.Context, users []*table.UserModel) (err error)
UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error)
GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
Get(ctx context.Context, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
Get(ctx context.Context, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
//userIDs是否存在 只要有一个存在就为true
IsExist(ctx context.Context, userIDs []string) (exist bool, err error)
}
@ -23,28 +24,28 @@ type UserController struct {
database UserDatabaseInterface
}
func (u *UserController) Find(ctx context.Context, userIDs []string) (users []*relation.User, err error) {
func (u *UserController) Find(ctx context.Context, userIDs []string) (users []*table.UserModel, err error) {
return u.database.Find(ctx, userIDs)
}
func (u *UserController) Create(ctx context.Context, users []*relation.User) error {
func (u *UserController) Create(ctx context.Context, users []*table.UserModel) error {
return u.database.Create(ctx, users)
}
func (u *UserController) Take(ctx context.Context, userID string) (user *relation.User, err error) {
func (u *UserController) Take(ctx context.Context, userID string) (user *table.UserModel, err error) {
return u.database.Take(ctx, userID)
}
func (u *UserController) Update(ctx context.Context, users []*relation.User) (err error) {
func (u *UserController) Update(ctx context.Context, users []*table.UserModel) (err error) {
return u.database.Update(ctx, users)
}
func (u *UserController) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
return u.database.UpdateByMap(ctx, userID, args)
}
func (u *UserController) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserController) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.database.GetByName(ctx, userName, showNumber, pageNumber)
}
func (u *UserController) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserController) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.database.GetByNameAndID(ctx, content, showNumber, pageNumber)
}
func (u *UserController) Get(ctx context.Context, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserController) Get(ctx context.Context, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.database.Get(ctx, showNumber, pageNumber)
}
func NewUserController(db *gorm.DB) *UserController {
@ -53,50 +54,50 @@ func NewUserController(db *gorm.DB) *UserController {
}
type UserDatabaseInterface interface {
Find(ctx context.Context, userIDs []string) (users []*relation.User, err error)
Create(ctx context.Context, users []*relation.User) error
Take(ctx context.Context, userID string) (user *relation.User, err error)
Update(ctx context.Context, users []*relation.User) (err error)
Find(ctx context.Context, userIDs []string) (users []*table.UserModel, err error)
Create(ctx context.Context, users []*table.UserModel) error
Take(ctx context.Context, userID string) (user *table.UserModel, err error)
Update(ctx context.Context, users []*table.UserModel) (err error)
UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error)
GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
Get(ctx context.Context, showNumber, pageNumber int32) (users []*relation.User, count int64, err error)
GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
Get(ctx context.Context, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error)
}
type UserDatabase struct {
sqlDB *relation.User
sqlDB *relation.UserGorm
}
func newUserDatabase(db *gorm.DB) *UserDatabase {
sqlDB := relation.NewUserDB(db)
sqlDB := relation.NewUserGorm(db)
database := &UserDatabase{
sqlDB: sqlDB,
}
return database
}
func (u *UserDatabase) Find(ctx context.Context, userIDs []string) (users []*relation.User, err error) {
func (u *UserDatabase) Find(ctx context.Context, userIDs []string) (users []*table.UserModel, err error) {
return u.sqlDB.Find(ctx, userIDs)
}
func (u *UserDatabase) Create(ctx context.Context, users []*relation.User) error {
func (u *UserDatabase) Create(ctx context.Context, users []*table.UserModel) error {
return u.sqlDB.Create(ctx, users)
}
func (u *UserDatabase) Take(ctx context.Context, userID string) (user *relation.User, err error) {
func (u *UserDatabase) Take(ctx context.Context, userID string) (user *table.UserModel, err error) {
return u.sqlDB.Take(ctx, userID)
}
func (u *UserDatabase) Update(ctx context.Context, users []*relation.User) (err error) {
func (u *UserDatabase) Update(ctx context.Context, users []*table.UserModel) (err error) {
return u.sqlDB.Update(ctx, users)
}
func (u *UserDatabase) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
return u.sqlDB.UpdateByMap(ctx, userID, args)
}
func (u *UserDatabase) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserDatabase) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.sqlDB.GetByName(ctx, userName, showNumber, pageNumber)
}
func (u *UserDatabase) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserDatabase) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.sqlDB.GetByNameAndID(ctx, content, showNumber, pageNumber)
}
func (u *UserDatabase) Get(ctx context.Context, showNumber, pageNumber int32) (users []*relation.User, count int64, err error) {
func (u *UserDatabase) Get(ctx context.Context, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
return u.sqlDB.Get(ctx, showNumber, pageNumber)
}

58
pkg/common/db/relation/black.go
View File

@ -1,58 +1,52 @@
package relation
import (
"Open_IM/pkg/common/db/table"
"Open_IM/pkg/common/tracelog"
"Open_IM/pkg/utils"
"context"
"gorm.io/gorm"
"time"
)
type Black struct {
OwnerUserID string `gorm:"column:owner_user_id;primary_key;size:64"`
BlockUserID string `gorm:"column:block_user_id;primary_key;size:64"`
CreateTime time.Time `gorm:"column:create_time"`
AddSource int32 `gorm:"column:add_source"`
OperatorUserID string `gorm:"column:operator_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
DB *gorm.DB `gorm:"-"`
type BlackGorm struct {
DB *gorm.DB
}
func NewBlack(db *gorm.DB) *Black {
var black Black
black.DB = db.Model(&Black{})
func NewBlackGorm(db *gorm.DB) *BlackGorm {
var black BlackGorm
black.DB = db
return &black
}
func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) {
func (b *BlackGorm) Create(ctx context.Context, blacks []*table.BlackModel) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(b.DB.Create(&blacks).Error, "")
return utils.Wrap(b.DB.Model(&table.BlackModel{}).Create(&blacks).Error, "")
}
func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) {
func (b *BlackGorm) Delete(ctx context.Context, blacks []*table.BlackModel) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(b.DB.Delete(blacks).Error, "")
return utils.Wrap(b.DB.Model(&table.BlackModel{}).Delete(blacks).Error, "")
}
func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
func (b *BlackGorm) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
}()
return utils.Wrap(b.DB.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
return utils.Wrap(b.DB.Model(&table.BlackModel{}).Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
}
func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
func (b *BlackGorm) Update(ctx context.Context, blacks []*table.BlackModel) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}()
return utils.Wrap(b.DB.Updates(&blacks).Error, "")
return utils.Wrap(b.DB.Model(&table.BlackModel{}).Updates(&blacks).Error, "")
}
func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black, err error) {
func (b *BlackGorm) Find(ctx context.Context, blacks []*table.BlackModel) (blackList []*table.BlackModel, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
}()
@ -60,33 +54,25 @@ func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black,
for _, black := range blacks {
where = append(where, []interface{}{black.OwnerUserID, black.BlockUserID})
}
return blackList, utils.Wrap(b.DB.Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
return blackList, utils.Wrap(b.DB.Model(&table.BlackModel{}).Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "")
}
func (b *Black) GetBlackIDs(ctx context.Context, ownerUserID string) (userIDs []string, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "userIDs", userIDs)
}()
err = utils.Wrap(b.DB.Where("owner_user_id = ?", ownerUserID).Pluck("block_user_id", &userIDs).Error, "")
return userIDs, err
}
func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (black *Black, err error) {
black = &Black{}
func (b *BlackGorm) Take(ctx context.Context, ownerUserID, blockUserID string) (black *table.BlackModel, err error) {
black = &table.BlackModel{}
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black)
}()
return black, utils.Wrap(b.DB.Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
return black, utils.Wrap(b.DB.Model(&table.BlackModel{}).Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
}
func (b *Black) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*Black, total int64, err error) {
func (b *BlackGorm) FindOwnerBlacks(ctx context.Context, ownerUserID string, pageNumber, showNumber int32) (blacks []*table.BlackModel, total int64, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blacks", blacks)
}()
err = b.DB.Model(b).Count(&total).Error
err = b.DB.Model(&table.BlackModel{}).Model(b).Count(&total).Error
if err != nil {
return nil, 0, utils.Wrap(err, "")
}
err = utils.Wrap(b.DB.Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&blacks).Error, "")
err = utils.Wrap(b.DB.Model(&table.BlackModel{}).Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&blacks).Error, "")
return
}

63
pkg/common/db/relation/user_model_k.go
View File

@ -1,107 +1,94 @@
package relation
import (
"Open_IM/pkg/common/db/table"
"Open_IM/pkg/common/tracelog"
"Open_IM/pkg/utils"
"context"
"fmt"
"gorm.io/gorm"
"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"`
DB *gorm.DB `gorm:"-" json:"-"`
type UserGorm struct {
DB *gorm.DB
}
func NewUserDB(db *gorm.DB) *User {
var user User
func NewUserGorm(db *gorm.DB) *UserGorm {
var user UserGorm
user.DB = db
return &user
}
func (u *User) Create(ctx context.Context, users []*User) (err error) {
func (u *UserGorm) Create(ctx context.Context, users []*table.UserModel) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}()
err = utils.Wrap(u.DB.Create(&users).Error, "")
err = utils.Wrap(u.DB.Model(&table.UserModel{}).Create(&users).Error, "")
return err
}
func (u *User) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
func (u *UserGorm) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args)
}()
return utils.Wrap(u.DB.Where("user_id = ?", userID).Updates(args).Error, "")
return utils.Wrap(u.DB.Model(&table.UserModel{}).Where("user_id = ?", userID).Updates(args).Error, "")
}
func (u *User) Update(ctx context.Context, users []*User) (err error) {
func (u *UserGorm) Update(ctx context.Context, users []*table.UserModel) (err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}()
return utils.Wrap(u.DB.Updates(&users).Error, "")
return utils.Wrap(u.DB.Model(&table.UserModel{}).Updates(&users).Error, "")
}
func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err error) {
func (u *UserGorm) Find(ctx context.Context, userIDs []string) (users []*table.UserModel, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users)
}()
err = utils.Wrap(u.DB.Where("user_id in (?)", userIDs).Find(&users).Error, "")
err = utils.Wrap(u.DB.Model(&table.UserModel{}).Where("user_id in (?)", userIDs).Find(&users).Error, "")
return users, err
}
func (u *User) Take(ctx context.Context, userID string) (user *User, err error) {
user = &User{}
func (u *UserGorm) Take(ctx context.Context, userID string) (user *table.UserModel, err error) {
user = &table.UserModel{}
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user)
}()
err = utils.Wrap(u.DB.Where("user_id = ?", userID).Take(&user).Error, "")
err = utils.Wrap(u.DB.Model(&table.UserModel{}).Where("user_id = ?", userID).Take(&user).Error, "")
return user, err
}
func (u *User) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*User, count int64, err error) {
func (u *UserGorm) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users, "count", count)
}()
err = u.DB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * pageNumber)).Find(&users).Error
err = u.DB.Model(&table.UserModel{}).Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * pageNumber)).Find(&users).Error
if err != nil {
return nil, 0, utils.Wrap(err, "")
}
return users, count, utils.Wrap(u.DB.Where(" name like ? ", fmt.Sprintf("%%%s%%", userName)).Count(&count).Error, "")
return users, count, utils.Wrap(u.DB.Model(&table.UserModel{}).Where(" name like ? ", fmt.Sprintf("%%%s%%", userName)).Count(&count).Error, "")
}
func (u *User) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*User, count int64, err error) {
func (u *UserGorm) GetByNameAndID(ctx context.Context, content string, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "content", content, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
}()
db := u.DB.Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content)
if err := db.Count(&count).Error; err != nil {
db := u.DB.Model(&table.UserModel{}).Where(" name like ? or user_id = ? ", fmt.Sprintf("%%%s%%", content), content)
if err := db.Model(&table.UserModel{}).Count(&count).Error; err != nil {
return nil, 0, utils.Wrap(err, "")
}
err = utils.Wrap(db.Limit(int(showNumber)).Offset(int(showNumber*pageNumber)).Find(&users).Error, "")
return
}
func (u *User) Get(ctx context.Context, showNumber, pageNumber int32) (users []*User, count int64, err error) {
func (u *UserGorm) Get(ctx context.Context, showNumber, pageNumber int32) (users []*table.UserModel, count int64, err error) {
defer func() {
tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "showNumber", showNumber, "pageNumber", pageNumber, "users", users, "count", count)
}()
err = u.DB.Model(u).Count(&count).Error
err = u.DB.Model(&table.UserModel{}).Model(u).Count(&count).Error
if err != nil {
return nil, 0, utils.Wrap(err, "")
}
err = utils.Wrap(u.DB.Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&users).Error, "")
err = utils.Wrap(u.DB.Model(&table.UserModel{}).Limit(int(showNumber)).Offset(int(pageNumber*showNumber)).Find(&users).Error, "")
return
}

24
pkg/common/db/table/table.go
View File

@ -89,3 +89,27 @@ type GroupRequestModel struct {
InviterUserID string `gorm:"column:inviter_user_id;size:64"`
Ex string `gorm:"column:ex;size:1024"`
}
type UserModel struct {
UserID string `gorm:"column:user_id;primary_key;size:64"`
Nickname string `gorm:"column:name;size:255"`
FaceURL string `gorm:"column:face_url;size:255"`
Gender int32 `gorm:"column:gender"`
PhoneNumber string `gorm:"column:phone_number;size:32"`
Birth time.Time `gorm:"column:birth"`
Email string `gorm:"column:email;size:64"`
Ex string `gorm:"column:ex;size:1024"`
CreateTime time.Time `gorm:"column:create_time;index:create_time"`
AppMangerLevel int32 `gorm:"column:app_manger_level"`
GlobalRecvMsgOpt int32 `gorm:"column:global_recv_msg_opt"`
status int32 `gorm:"column:status"`
}
type BlackModel 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"`
}

4
pkg/common/token_verify/jwt_token.go
View File

@ -73,6 +73,10 @@ func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
return constant.ErrIdentity.Wrap(utils.GetSelfFuncName())
}
func IsAppManagerUid(ctx context.Context) bool {
return utils.IsContain(tracelog.GetOpUserID(ctx), config.Config.Manager.AppManagerUid)
}
func CheckAdmin(ctx context.Context) error {
if utils.IsContain(tracelog.GetOpUserID(ctx), config.Config.Manager.AppManagerUid) {
return nil