From 40470bc320d2b9bb720be185cc386f24bdd1ed16 Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Wed, 1 Feb 2023 11:23:01 +0800 Subject: [PATCH 1/8] errcode --- pkg/common/db/cache/black.go | 64 +++++++++++++++++++++++ pkg/common/db/cache/friend.go | 65 ++++++++++++++++++++++++ pkg/common/db/cache/group.go | 57 ++++++++++++++++++--- pkg/common/db/cache/rockscache.go | 6 +-- pkg/common/db/controller/group.go | 4 +- pkg/common/db/localcache/localCache.go | 24 +++++++++ pkg/common/db/relation/black.go | 14 +++-- pkg/common/db/relation/friend_model_k.go | 15 +++++- 8 files changed, 231 insertions(+), 18 deletions(-) create mode 100644 pkg/common/db/cache/black.go create mode 100644 pkg/common/db/cache/friend.go create mode 100644 pkg/common/db/localcache/localCache.go diff --git a/pkg/common/db/cache/black.go b/pkg/common/db/cache/black.go new file mode 100644 index 000000000..fda6ea04d --- /dev/null +++ b/pkg/common/db/cache/black.go @@ -0,0 +1,64 @@ +package cache + +import ( + "Open_IM/pkg/common/db/relation" + "Open_IM/pkg/common/tracelog" + "Open_IM/pkg/utils" + "context" + "encoding/json" + "github.com/dtm-labs/rockscache" + "time" +) + +const ( + blackIDsKey = "BLACK_IDS:" + blackExpireTime = time.Second * 60 * 60 * 12 +) + +type BlackCache struct { + blackDB *relation.Black + expireTime time.Duration + rcClient *rockscache.Client +} + +func NewBlackCache(blackDB *relation.Black) *BlackCache { + return &BlackCache{ + blackDB: nil, + expireTime: 0, + rcClient: nil, + } +} + +func (b *BlackCache) getBlackIDsKey(ownerUserID string) string { + return blackIDsKey + ownerUserID +} + +func (b *BlackCache) GetBlackIDs(ctx context.Context, userID string) (blackIDs []string, err error) { + getBlackIDList := func() (string, error) { + blackIDs, err := b.blackDB.GetBlackIDs(ctx, userID) + if err != nil { + return "", utils.Wrap(err, "") + } + bytes, err := json.Marshal(blackIDs) + if err != nil { + return "", utils.Wrap(err, "") + } + return string(bytes), nil + } + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs) + }() + blackIDListStr, err := b.rcClient.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList) + if err != nil { + return nil, utils.Wrap(err, "") + } + err = json.Unmarshal([]byte(blackIDListStr), &blackIDs) + return blackIDs, utils.Wrap(err, "") +} + +func (b *BlackCache) DelBlackIDListFromCache(ctx context.Context, userID string) (err error) { + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx) + }() + return b.rcClient.TagAsDeleted(blackListCache + userID) +} diff --git a/pkg/common/db/cache/friend.go b/pkg/common/db/cache/friend.go new file mode 100644 index 000000000..65d128159 --- /dev/null +++ b/pkg/common/db/cache/friend.go @@ -0,0 +1,65 @@ +package cache + +import ( + "Open_IM/pkg/common/db/relation" + "Open_IM/pkg/common/tracelog" + "Open_IM/pkg/utils" + "context" + "encoding/json" + "github.com/dtm-labs/rockscache" + "github.com/go-redis/redis/v8" + "time" +) + +const ( + friendExpireTime = time.Second * 60 * 60 * 12 + friendIDsKey = "FRIEND_IDS:" +) + +type FriendCache struct { + friendDB *relation.Friend + expireTime time.Duration + rcClient *rockscache.Client +} + +func NewFriendCache(rdb redis.UniversalClient, friendDB *relation.Friend, options rockscache.Options) *FriendCache { + return &FriendCache{ + friendDB: friendDB, + expireTime: friendExpireTime, + rcClient: rockscache.NewClient(rdb, options), + } +} + +func (f *FriendCache) getFriendRelationKey(ownerUserID string) string { + return friendIDsKey + ownerUserID +} + +func (f *FriendCache) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDs []string, err error) { + getFriendIDList := func() (string, error) { + friendIDList, err := f.friendDB.GetFriendIDs(ctx, ownerUserID) + if err != nil { + return "", err + } + bytes, err := json.Marshal(friendIDList) + if err != nil { + return "", utils.Wrap(err, "") + } + return string(bytes), nil + } + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "friendIDs", friendIDs) + }() + friendIDListStr, err := f.rcClient.Fetch(f.getFriendRelationKey(ownerUserID), f.expireTime, getFriendIDList) + if err != nil { + return nil, err + } + err = json.Unmarshal([]byte(friendIDListStr), &friendIDs) + return friendIDs, utils.Wrap(err, "") +} + +func (f *FriendCache) DelFriendIDs(ctx context.Context, ownerUserID string) (err error) { + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID) + }() + return f.rcClient.TagAsDeleted(f.getFriendRelationKey(ownerUserID)) +} diff --git a/pkg/common/db/cache/group.go b/pkg/common/db/cache/group.go index 50563ca88..2c9109015 100644 --- a/pkg/common/db/cache/group.go +++ b/pkg/common/db/cache/group.go @@ -2,6 +2,7 @@ package cache import ( "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/db/localcache" "Open_IM/pkg/common/db/relation" "Open_IM/pkg/common/db/unrelation" "Open_IM/pkg/common/tracelog" @@ -39,18 +40,13 @@ type GroupCache struct { //local cache cacheGroupMtx sync.RWMutex - cacheGroupMemberUserIDs map[string]*GroupMemberIDsHash -} - -type GroupMemberIDsHash struct { - MemberListHash uint64 - UserIDs []string + cacheGroupMemberUserIDs map[string]*localcache.GroupMemberIDsHash } func NewGroupCache(rdb redis.UniversalClient, groupDB *relation.Group, groupMemberDB *relation.GroupMember, groupRequestDB *relation.GroupRequest, mongoClient *unrelation.SuperGroupMgoDB, opts rockscache.Options) *GroupCache { return &GroupCache{rcClient: rockscache.NewClient(rdb, opts), expireTime: groupExpireTime, group: groupDB, groupMember: groupMemberDB, groupRequest: groupRequestDB, redisClient: NewRedisClient(rdb), - mongoDB: mongoClient, cacheGroupMemberUserIDs: make(map[string]*GroupMemberIDsHash, 0), + mongoDB: mongoClient, cacheGroupMemberUserIDs: make(map[string]*localcache.GroupMemberIDsHash, 0), } } @@ -287,7 +283,7 @@ func (g *GroupCache) LocalGetGroupMemberIDs(ctx context.Context, groupID string) if err != nil { return nil, err } - g.cacheGroupMemberUserIDs[groupID] = &GroupMemberIDsHash{ + g.cacheGroupMemberUserIDs[groupID] = &localcache.GroupMemberIDsHash{ MemberListHash: remoteHash, UserIDs: groupMemberIDsRemote, } @@ -350,6 +346,51 @@ func (g *GroupCache) GetGroupMemberInfo(ctx context.Context, groupID, userID str return groupMember, utils.Wrap(err, "") } +func (g *GroupCache) GetGroupMembersInfo(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relation.GroupMember, err error) { + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers) + }() + groupMemberIDList, err := g.GetGroupMemberIDs(ctx, groupID) + if err != nil { + return nil, err + } + if count < 0 || offset < 0 { + return nil, nil + } + var groupMemberList []*relation.GroupMember + var start, stop int32 + start = offset + stop = offset + count + l := int32(len(groupMemberIDList)) + if start > stop { + return nil, nil + } + if start >= l { + return nil, nil + } + if count != 0 { + if stop >= l { + stop = l + } + groupMemberIDList = groupMemberIDList[start:stop] + } else { + if l < 1000 { + stop = l + } else { + stop = 1000 + } + groupMemberIDList = groupMemberIDList[start:stop] + } + for _, userID := range groupMemberIDList { + groupMember, err := g.GetGroupMemberInfo(ctx, groupID, userID) + if err != nil { + return + } + groupMembers = append(groupMembers, groupMember) + } + return groupMemberList, nil +} + func (g *GroupCache) DelGroupMemberInfo(ctx context.Context, groupID, userID string) (err error) { defer func() { tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID) diff --git a/pkg/common/db/cache/rockscache.go b/pkg/common/db/cache/rockscache.go index e17ea7c81..692e5914b 100644 --- a/pkg/common/db/cache/rockscache.go +++ b/pkg/common/db/cache/rockscache.go @@ -21,15 +21,15 @@ import ( const ( //userInfoCache = "USER_INFO_CACHE:" - friendRelationCache = "FRIEND_RELATION_CACHE:" - blackListCache = "BLACK_LIST_CACHE:" + //friendRelationCache = "FRIEND_RELATION_CACHE:" + blackListCache = "BLACK_LIST_CACHE:" //groupCache = "GROUP_CACHE:" //groupInfoCache = "GROUP_INFO_CACHE:" //groupOwnerIDCache = "GROUP_OWNER_ID:" //joinedGroupListCache = "JOINED_GROUP_LIST_CACHE:" //groupMemberInfoCache = "GROUP_MEMBER_INFO_CACHE:" //groupAllMemberInfoCache = "GROUP_ALL_MEMBER_INFO_CACHE:" - allFriendInfoCache = "ALL_FRIEND_INFO_CACHE:" + //allFriendInfoCache = "ALL_FRIEND_INFO_CACHE:" //joinedSuperGroupListCache = "JOINED_SUPER_GROUP_LIST_CACHE:" //groupMemberListHashCache = "GROUP_MEMBER_LIST_HASH_CACHE:" //groupMemberNumCache = "GROUP_MEMBER_NUM_CACHE:" diff --git a/pkg/common/db/controller/group.go b/pkg/common/db/controller/group.go index be5d4caa1..cda04cc86 100644 --- a/pkg/common/db/controller/group.go +++ b/pkg/common/db/controller/group.go @@ -137,13 +137,13 @@ func newGroupDatabase(db *gorm.DB, rdb redis.UniversalClient, mgoClient *mongo.C groupDB := relation.NewGroupDB(db) groupMemberDB := relation.NewGroupMemberDB(db) groupRequestDB := relation.NewGroupRequest(db) - newDB := db + newDB := *db superGroupMgoDB := unrelation.NewSuperGroupMgoDB(mgoClient) database := &GroupDataBase{ groupDB: groupDB, groupMemberDB: groupMemberDB, groupRequestDB: groupRequestDB, - db: newDB, + db: &newDB, cache: cache.NewGroupCache(rdb, groupDB, groupMemberDB, groupRequestDB, superGroupMgoDB, rockscache.Options{ RandomExpireAdjustment: 0.2, DisableCacheRead: false, diff --git a/pkg/common/db/localcache/localCache.go b/pkg/common/db/localcache/localCache.go new file mode 100644 index 000000000..9cfcec090 --- /dev/null +++ b/pkg/common/db/localcache/localCache.go @@ -0,0 +1,24 @@ +package localcache + +import "google.golang.org/grpc" + +type GroupLocalCache struct { + cache map[string]GroupMemberIDsHash + rpc *grpc.ClientConn +} + +type GroupMemberIDsHash struct { + MemberListHash uint64 + UserIDs []string +} + +func NewGroupMemberIDsLocalCache(rpc *grpc.ClientConn) GroupLocalCache { + return GroupLocalCache{ + cache: make(map[string]GroupMemberIDsHash, 0), + rpc: rpc, + } +} + +func (g *GroupMemberIDsHash) GetGroupMemberIDs(groupID string) []string { + return []string{} +} diff --git a/pkg/common/db/relation/black.go b/pkg/common/db/relation/black.go index e666ea81d..4f7e40122 100644 --- a/pkg/common/db/relation/black.go +++ b/pkg/common/db/relation/black.go @@ -20,7 +20,7 @@ type Black struct { func NewBlack(db *gorm.DB) *Black { var black Black - black.DB = db + black.DB = db.Model(&Black{}) return &black } @@ -35,7 +35,7 @@ func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) { defer func() { tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks) }() - return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "") + return utils.Wrap(b.DB.Delete(blacks).Error, "") } func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) { @@ -60,7 +60,15 @@ 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(GroupMemberDB.Where("(owner_user_id, block_user_id) in ?", where).Find(&blackList).Error, "") + return blackList, utils.Wrap(b.DB.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) { diff --git a/pkg/common/db/relation/friend_model_k.go b/pkg/common/db/relation/friend_model_k.go index 519e78fec..bb70021f8 100644 --- a/pkg/common/db/relation/friend_model_k.go +++ b/pkg/common/db/relation/friend_model_k.go @@ -26,7 +26,7 @@ type FriendUser struct { func NewFriendDB(db *gorm.DB) *Friend { var friend Friend - friend.DB = initModel(db, friend) + friend.DB = db.Model(friend) return &friend } @@ -63,7 +63,7 @@ func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, re defer func() { tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark) }() - return utils.Wrap(f.DB.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "") + return utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "") } func (f *Friend) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { @@ -80,6 +80,17 @@ func (f *Friend) FindFriendUserID(ctx context.Context, friendUserID string) (fri return friends, utils.Wrap(f.DB.Where("friend_user_id = ?", friendUserID).Find(&friends).Error, "") } +func (f *Friend) GetFriendIDs(ctx context.Context, ownerUserID string) (friendIDList []string, err error) { + defer func() { + tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendIDList", friendIDList) + }() + err = f.DB.Where("owner_user_id=?", ownerUserID).Pluck("friend_user_id", &friendIDList).Error + if err != nil { + return nil, err + } + return friendIDList, nil +} + func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) { friend = &Friend{} defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend) From d4952ebc160b789459f273e795ccf727efb3c0a8 Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Wed, 1 Feb 2023 17:11:44 +0800 Subject: [PATCH 2/8] errcode --- pkg/common/db/localcache/group.go | 36 ++++++++++++++++++++++++++ pkg/common/db/localcache/localCache.go | 24 ----------------- 2 files changed, 36 insertions(+), 24 deletions(-) create mode 100644 pkg/common/db/localcache/group.go delete mode 100644 pkg/common/db/localcache/localCache.go diff --git a/pkg/common/db/localcache/group.go b/pkg/common/db/localcache/group.go new file mode 100644 index 000000000..a76bc6edb --- /dev/null +++ b/pkg/common/db/localcache/group.go @@ -0,0 +1,36 @@ +package localcache + +import ( + "Open_IM/pkg/proto/group" + "context" + "google.golang.org/grpc" +) + +type GroupLocalCache struct { + cache map[string]GroupMemberIDsHash + rpc *grpc.ClientConn + group group.GroupClient +} + +type GroupMemberIDsHash struct { + memberListHash uint64 + userIDs []string +} + +func NewGroupMemberIDsLocalCache(rpc *grpc.ClientConn) GroupLocalCache { + return GroupLocalCache{ + cache: make(map[string]GroupMemberIDsHash, 0), + rpc: rpc, + group: group.NewGroupClient(rpc), + } +} + +func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) []string { + _, err := g.group.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{ + GroupIDs: nil, + }) + if err != nil { + return nil + } + return []string{} +} diff --git a/pkg/common/db/localcache/localCache.go b/pkg/common/db/localcache/localCache.go deleted file mode 100644 index 9cfcec090..000000000 --- a/pkg/common/db/localcache/localCache.go +++ /dev/null @@ -1,24 +0,0 @@ -package localcache - -import "google.golang.org/grpc" - -type GroupLocalCache struct { - cache map[string]GroupMemberIDsHash - rpc *grpc.ClientConn -} - -type GroupMemberIDsHash struct { - MemberListHash uint64 - UserIDs []string -} - -func NewGroupMemberIDsLocalCache(rpc *grpc.ClientConn) GroupLocalCache { - return GroupLocalCache{ - cache: make(map[string]GroupMemberIDsHash, 0), - rpc: rpc, - } -} - -func (g *GroupMemberIDsHash) GetGroupMemberIDs(groupID string) []string { - return []string{} -} From 2e19e3109ee64234d0d5422a7aeb4ada7d766427 Mon Sep 17 00:00:00 2001 From: skiffer-git <44203734@qq.com> Date: Wed, 1 Feb 2023 17:39:08 +0800 Subject: [PATCH 3/8] Error code standardization --- internal/common/convert/convert.go | 87 +++++++++++++++++++----------- pkg/common/db/relation/black.go | 48 ++++++++--------- pkg/common/db/table/table.go | 9 ++++ 3 files changed, 86 insertions(+), 58 deletions(-) diff --git a/internal/common/convert/convert.go b/internal/common/convert/convert.go index 84aaab1b8..020db86bd 100644 --- a/internal/common/convert/convert.go +++ b/internal/common/convert/convert.go @@ -23,8 +23,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 +35,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 +57,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 +66,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 +81,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)) @@ -106,6 +122,15 @@ type DBBlack struct { *relation.Black } +func (*PBBlack) PB2DB(friendRequests []*sdk.BlackInfo) (DBFriendRequests []*table., err error) { + +} + +func (*DBBlack) DB2PB(friendRequests []*table.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) { + +} + + func NewDBBlack(black *relation.Black) *DBBlack { return &DBBlack{Black: black} } @@ -137,11 +162,11 @@ 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 NewDBGroup(group *table.GroupModel) *DBGroup { + return &DBGroup{GroupModel: group} } type PBGroup struct { @@ -152,8 +177,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 +205,11 @@ 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 NewDBGroupMember(groupMember *table.GroupMemberModel) *DBGroupMember { + return &DBGroupMember{GroupMemberModel: groupMember} } type PBGroupMember struct { @@ -195,8 +220,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 +249,11 @@ 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 NewDBGroupRequest(groupRequest *table.GroupRequestModel) *DBGroupRequest { + return &DBGroupRequest{GroupRequestModel: groupRequest} } type PBGroupRequest struct { @@ -239,8 +264,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 +280,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 +295,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 +306,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 +317,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)) diff --git a/pkg/common/db/relation/black.go b/pkg/common/db/relation/black.go index e666ea81d..06c00889c 100644 --- a/pkg/common/db/relation/black.go +++ b/pkg/common/db/relation/black.go @@ -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 +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(GroupMemberDB.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,25 +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(GroupMemberDB.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) 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 } diff --git a/pkg/common/db/table/table.go b/pkg/common/db/table/table.go index bdb4a98a4..052c9cc05 100644 --- a/pkg/common/db/table/table.go +++ b/pkg/common/db/table/table.go @@ -104,3 +104,12 @@ type UserModel struct { 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"` +} From a5a1cbb077a00697fc1cdda2856c5b713c4e2376 Mon Sep 17 00:00:00 2001 From: skiffer-git <44203734@qq.com> Date: Wed, 1 Feb 2023 17:45:47 +0800 Subject: [PATCH 4/8] Error code standardization --- internal/common/convert/convert.go | 40 +++++++++++++++++++++++------- 1 file changed, 31 insertions(+), 9 deletions(-) diff --git a/internal/common/convert/convert.go b/internal/common/convert/convert.go index 020db86bd..be485046d 100644 --- a/internal/common/convert/convert.go +++ b/internal/common/convert/convert.go @@ -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" @@ -119,20 +118,19 @@ func (db *DBFriendRequest) Convert() (*sdk.FriendRequest, error) { } type DBBlack struct { - *relation.Black + *table.BlackModel } -func (*PBBlack) PB2DB(friendRequests []*sdk.BlackInfo) (DBFriendRequests []*table., err error) { +func (*PBBlack) PB2DB(blacks []*sdk.BlackInfo) (DBBlacks []*table.BlackModel, err error) { } -func (*DBBlack) DB2PB(friendRequests []*table.FriendRequestModel) (PBFriendRequests []*sdk.FriendRequest, err error) { +func (*DBBlack) DB2PB(blacks []*table.BlackModel) (PBBlacks []*sdk.BlackInfo, err error) { } - -func NewDBBlack(black *relation.Black) *DBBlack { - return &DBBlack{Black: black} +func NewDBBlack(black *table.BlackModel) *DBBlack { + return &DBBlack{BlackModel: black} } type PBBlack struct { @@ -143,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 @@ -165,6 +163,14 @@ type DBGroup struct { *table.GroupModel } +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} } @@ -208,6 +214,14 @@ type DBGroupMember struct { *table.GroupMemberModel } +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} } @@ -252,6 +266,14 @@ type DBGroupRequest struct { *table.GroupRequestModel } +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} } From 6658566144f274c0345f007ada0c993ddfbf3635 Mon Sep 17 00:00:00 2001 From: skiffer-git <44203734@qq.com> Date: Wed, 1 Feb 2023 17:54:16 +0800 Subject: [PATCH 5/8] Error code standardization --- internal/rpc/friend/black.go | 24 ++++++++++-------------- internal/rpc/user/user.go | 11 ++++++----- pkg/common/db/controller/black.go | 8 ++++---- 3 files changed, 20 insertions(+), 23 deletions(-) diff --git a/internal/rpc/friend/black.go b/internal/rpc/friend/black.go index f2beb5a9d..91bcf9236 100644 --- a/internal/rpc/friend/black.go +++ b/internal/rpc/friend/black.go @@ -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 } diff --git a/internal/rpc/user/user.go b/internal/rpc/user/user.go index e4df2f3f2..68e9958ec 100644 --- a/internal/rpc/user/user.go +++ b/internal/rpc/user/user.go @@ -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" @@ -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 } diff --git a/pkg/common/db/controller/black.go b/pkg/common/db/controller/black.go index 6ca049ef4..e8a3e5355 100644 --- a/pkg/common/db/controller/black.go +++ b/pkg/common/db/controller/black.go @@ -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) } From cd6c056e73fe504595eeeb8b9b07d75d01e7f439 Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Wed, 1 Feb 2023 18:42:04 +0800 Subject: [PATCH 6/8] errcode --- go.mod | 2 +- go.sum | 2 ++ internal/rpc/group/group.go | 45 ++++++++++++++++++++----------------- pkg/getcdv3/temp.go | 35 ----------------------------- 4 files changed, 27 insertions(+), 57 deletions(-) delete mode 100644 pkg/getcdv3/temp.go diff --git a/go.mod b/go.mod index 95e4d2391..fcd300597 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.15 require ( firebase.google.com/go v3.13.0+incompatible - github.com/OpenIMSDK/getcdv3 v1.0.3 + github.com/OpenIMSDK/getcdv3 v1.0.4 github.com/OpenIMSDK/open_utils v1.0.8 github.com/Shopify/sarama v1.32.0 github.com/alibabacloud-go/darabonba-openapi v0.1.11 diff --git a/go.sum b/go.sum index 814ce471e..0c4dff748 100644 --- a/go.sum +++ b/go.sum @@ -393,6 +393,8 @@ github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6Xge github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/OpenIMSDK/getcdv3 v1.0.3 h1:3/j92MuDPFhAJYBy/ht0qnybdaaCezefF1pMTClvvq4= github.com/OpenIMSDK/getcdv3 v1.0.3/go.mod h1:ZvsBwAjOZZr7HBF3SytJaHCltuOfBKbM1vLSCjut7kw= +github.com/OpenIMSDK/getcdv3 v1.0.4 h1:wKpLcp1gbLbh+fa7b5iCL4fTBLm87hB0+p0ZQMg9tK8= +github.com/OpenIMSDK/getcdv3 v1.0.4/go.mod h1:ZvsBwAjOZZr7HBF3SytJaHCltuOfBKbM1vLSCjut7kw= github.com/OpenIMSDK/open_log v1.0.0 h1:ZQ908aWgPqfHOfkQ/oFSV20AZdRwPw+sZjC/sAPd5cA= github.com/OpenIMSDK/open_log v1.0.0/go.mod h1:qWvqF4iT2qBAP1eGGbinc0aAng1Y25X8A9Si1WS3oB4= github.com/OpenIMSDK/open_utils v1.0.1/go.mod h1:PPRayByXnfu8PR5Xv9wzUMBrm1BV3y7s29GGg8ae47s= diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index d3f8eebe5..99ec555da 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -16,8 +16,8 @@ import ( "Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/tracelog" "fmt" + "github.com/OpenIMSDK/getcdv3" - "Open_IM/pkg/getcdv3" pbConversation "Open_IM/pkg/proto/conversation" pbGroup "Open_IM/pkg/proto/group" open_im_sdk "Open_IM/pkg/proto/sdk_ws" @@ -42,6 +42,9 @@ type groupServer struct { etcdSchema string etcdAddr []string controller.GroupInterface + + userRpc pbUser.UserClient + conversationRpc pbConversation.ConversationClient } func NewGroupServer(port int) *groupServer { @@ -52,12 +55,29 @@ func NewGroupServer(port int) *groupServer { etcdSchema: config.Config.Etcd.EtcdSchema, etcdAddr: config.Config.Etcd.EtcdAddr, } + ttl := 10 + etcdClient, err := getcdv3.NewEtcdConn(g.rpcRegisterName, strings.Join(g.etcdAddr, ","), config.Config.RpcRegisterIP, config.Config.Etcd.UserName, config.Config.Etcd.Password, port, ttl) + if err != nil { + panic("NewEtcdConn failed" + err.Error()) + } + err = etcdClient.RegisterEtcd("", g.rpcRegisterName) + if err != nil { + panic("NewEtcdConn failed" + err.Error()) + } + etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImUserName, config.Config.RpcPort.OpenImUserPort) + conn := etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImUserName) + g.userRpc = pbUser.NewUserClient(conn) + + etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImConversationName, config.Config.RpcPort.OpenImConversationPort) + conn = etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImConversationName) + g.conversationRpc = pbConversation.NewConversationClient(conn) + //mysql init var mysql relation.Mysql var mongo unrelation.Mongo var groupModel table.GroupModel var redis cache.RedisClient - err := mysql.InitConn().AutoMigrateModel(&groupModel) + err = mysql.InitConn().AutoMigrateModel(&groupModel) if err != nil { panic("db init err:" + err.Error()) } @@ -870,19 +890,6 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf } if req.GroupInfoForSet.Notification != "" { //get group member user id - getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: tracelog.GetOperationID(ctx), GroupID: req.GroupInfoForSet.GroupID} - etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) - if err != nil { - return nil, err - } - client := pbCache.NewCacheClient(etcdConn) - cacheResp, err := client.GetGroupMemberIDListFromCache(ctx, getGroupMemberIDListFromCacheReq) - if err != nil { - return nil, err - } - if err = constant.CommonResp2Err(cacheResp.CommonResp); err != nil { - return nil, err - } var conversationReq pbConversation.ModifyConversationFieldReq conversation := pbConversation.Conversation{ OwnerUserID: tracelog.GetOpUserID(ctx), @@ -895,12 +902,8 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf conversationReq.FieldType = constant.FieldGroupAtType conversation.GroupAtType = constant.GroupNotification conversationReq.UserIDList = cacheResp.UserIDList - nEtcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImConversationName) - if err != nil { - return nil, err - } - nClient := pbConversation.NewConversationClient(nEtcdConn) - conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq) + + _, err := s.conversationRpc.ModifyConversationField(ctx, &conversationReq) tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) } return resp, nil diff --git a/pkg/getcdv3/temp.go b/pkg/getcdv3/temp.go deleted file mode 100644 index 797271264..000000000 --- a/pkg/getcdv3/temp.go +++ /dev/null @@ -1,35 +0,0 @@ -package getcdv3 - -import ( - "Open_IM/pkg/common/config" - "Open_IM/pkg/common/constant" - "Open_IM/pkg/common/tracelog" - "context" - "github.com/OpenIMSDK/getcdv3" - "google.golang.org/grpc" - "strings" -) - -func GetDefaultConn(arg1, arg2, arg3, arg4 string) *grpc.ClientConn { - return getcdv3.GetConn(arg1, arg2, arg3, arg4, config.Config.Etcd.UserName, config.Config.Etcd.Password) -} - -func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) { - defer func() { - tracelog.SetCtxInfo(ctx, "GetConn", err, "serviceName", serviceName) - }() - conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), - serviceName, tracelog.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password) - if conn == nil { - return nil, constant.ErrInternalServer - } - 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) -} From 803ecd3f92c17d449d2893c3b56f00ed8fe76c05 Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Wed, 1 Feb 2023 19:31:39 +0800 Subject: [PATCH 7/8] errcode --- internal/rpc/group/group.go | 2 +- pkg/common/db/localcache/group.go | 4 +- pkg/common/db/relation/chat_log_model.go | 1 - pkg/common/db/table/{table.go => relation.go} | 0 pkg/common/db/table/unrelation.go | 56 ++++++++++++ pkg/common/db/unrelation/office.go | 88 +++++-------------- pkg/common/db/unrelation/super_group.go | 23 ++--- 7 files changed, 89 insertions(+), 85 deletions(-) rename pkg/common/db/table/{table.go => relation.go} (100%) create mode 100644 pkg/common/db/table/unrelation.go diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index a36cc3a0f..88135d793 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -56,7 +56,7 @@ func NewGroupServer(port int) *groupServer { etcdAddr: config.Config.Etcd.EtcdAddr, } ttl := 10 - etcdClient, err := getcdv3.NewEtcdConn(g.rpcRegisterName, strings.Join(g.etcdAddr, ","), config.Config.RpcRegisterIP, config.Config.Etcd.UserName, config.Config.Etcd.Password, port, ttl) + etcdClient, err := getcdv3.NewEtcdConn(config.Config.Etcd.EtcdSchema, strings.Join(g.etcdAddr, ","), config.Config.RpcRegisterIP, config.Config.Etcd.UserName, config.Config.Etcd.Password, port, ttl) if err != nil { panic("NewEtcdConn failed" + err.Error()) } diff --git a/pkg/common/db/localcache/group.go b/pkg/common/db/localcache/group.go index a76bc6edb..17aa53eac 100644 --- a/pkg/common/db/localcache/group.go +++ b/pkg/common/db/localcache/group.go @@ -4,9 +4,11 @@ import ( "Open_IM/pkg/proto/group" "context" "google.golang.org/grpc" + "sync" ) type GroupLocalCache struct { + lock sync.Mutex cache map[string]GroupMemberIDsHash rpc *grpc.ClientConn group group.GroupClient @@ -26,7 +28,7 @@ func NewGroupMemberIDsLocalCache(rpc *grpc.ClientConn) GroupLocalCache { } func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string) []string { - _, err := g.group.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{ + resp, err := g.group.GetGroupAbstractInfo(ctx, &group.GetGroupAbstractInfoReq{ GroupIDs: nil, }) if err != nil { diff --git a/pkg/common/db/relation/chat_log_model.go b/pkg/common/db/relation/chat_log_model.go index 03583cfb5..2266c9275 100644 --- a/pkg/common/db/relation/chat_log_model.go +++ b/pkg/common/db/relation/chat_log_model.go @@ -58,7 +58,6 @@ func (c *ChatLog) Create(msg pbMsg.MsgDataToMQ) error { EmitDefaults: false, } chatLog.Content, _ = marshaler.MarshalToString(&tips) - } else { chatLog.Content = string(msg.MsgData.Content) } diff --git a/pkg/common/db/table/table.go b/pkg/common/db/table/relation.go similarity index 100% rename from pkg/common/db/table/table.go rename to pkg/common/db/table/relation.go diff --git a/pkg/common/db/table/unrelation.go b/pkg/common/db/table/unrelation.go new file mode 100644 index 000000000..e79d4f4bb --- /dev/null +++ b/pkg/common/db/table/unrelation.go @@ -0,0 +1,56 @@ +package table + +type SuperGroup struct { + GroupID string `bson:"group_id" json:"groupID"` + MemberIDList []string `bson:"member_id_list" json:"memberIDList"` +} + +type UserToSuperGroup struct { + UserID string `bson:"user_id" json:"userID"` + GroupIDList []string `bson:"group_id_list" json:"groupIDList"` +} + +type Tag struct { + UserID string `bson:"user_id"` + TagID string `bson:"tag_id"` + TagName string `bson:"tag_name"` + UserList []string `bson:"user_list"` +} + +type CommonUser struct { + UserID string `bson:"user_id"` + UserName string `bson:"user_name"` +} + +type TagSendLog struct { + UserList []CommonUser `bson:"tag_list"` + SendID string `bson:"send_id"` + SenderPlatformID int32 `bson:"sender_platform_id"` + Content string `bson:"content"` + SendTime int64 `bson:"send_time"` +} + +type WorkMoment struct { + WorkMomentID string `bson:"work_moment_id"` + UserID string `bson:"user_id"` + UserName string `bson:"user_name"` + FaceURL string `bson:"face_url"` + Content string `bson:"content"` + LikeUserList []*CommonUser `bson:"like_user_list"` + AtUserList []*CommonUser `bson:"at_user_list"` + PermissionUserList []*CommonUser `bson:"permission_user_list"` + Comments []*CommonUser `bson:"comments"` + PermissionUserIDList []string `bson:"permission_user_id_list"` + Permission int32 `bson:"permission"` + CreateTime int32 `bson:"create_time"` +} + +type Comment struct { + UserID string `bson:"user_id" json:"user_id"` + UserName string `bson:"user_name" json:"user_name"` + ReplyUserID string `bson:"reply_user_id" json:"reply_user_id"` + ReplyUserName string `bson:"reply_user_name" json:"reply_user_name"` + ContentID string `bson:"content_id" json:"content_id"` + Content string `bson:"content" json:"content"` + CreateTime int32 `bson:"create_time" json:"create_time"` +} diff --git a/pkg/common/db/unrelation/office.go b/pkg/common/db/unrelation/office.go index e0e3c08e2..8bb4e025f 100644 --- a/pkg/common/db/unrelation/office.go +++ b/pkg/common/db/unrelation/office.go @@ -3,6 +3,7 @@ package unrelation import ( "Open_IM/pkg/common/config" "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/db/table" "Open_IM/pkg/utils" "context" "go.mongodb.org/mongo-driver/bson" @@ -22,57 +23,12 @@ type OfficeMgoDB struct { WorkMomentCollection *mongo.Collection } -type Tag struct { - UserID string `bson:"user_id"` - TagID string `bson:"tag_id"` - TagName string `bson:"tag_name"` - UserList []string `bson:"user_list"` -} - -type commonUser struct { - UserID string `bson:"user_id"` - UserName string `bson:"user_name"` -} - -type TagSendLog struct { - UserList []commonUser `bson:"tag_list"` - SendID string `bson:"send_id"` - SenderPlatformID int32 `bson:"sender_platform_id"` - Content string `bson:"content"` - SendTime int64 `bson:"send_time"` -} - -type WorkMoment struct { - WorkMomentID string `bson:"work_moment_id"` - UserID string `bson:"user_id"` - UserName string `bson:"user_name"` - FaceURL string `bson:"face_url"` - Content string `bson:"content"` - LikeUserList []*commonUser `bson:"like_user_list"` - AtUserList []*commonUser `bson:"at_user_list"` - PermissionUserList []*commonUser `bson:"permission_user_list"` - Comments []*commonUser `bson:"comments"` - PermissionUserIDList []string `bson:"permission_user_id_list"` - Permission int32 `bson:"permission"` - CreateTime int32 `bson:"create_time"` -} - -type Comment struct { - UserID string `bson:"user_id" json:"user_id"` - UserName string `bson:"user_name" json:"user_name"` - ReplyUserID string `bson:"reply_user_id" json:"reply_user_id"` - ReplyUserName string `bson:"reply_user_name" json:"reply_user_name"` - ContentID string `bson:"content_id" json:"content_id"` - Content string `bson:"content" json:"content"` - CreateTime int32 `bson:"create_time" json:"create_time"` -} - func NewOfficeMgoDB(mgoDB *mongo.Database) *OfficeMgoDB { return &OfficeMgoDB{mgoDB: mgoDB, TagCollection: mgoDB.Collection(cTag), TagSendLogCollection: mgoDB.Collection(cSendLog), WorkMomentCollection: mgoDB.Collection(cSendLog)} } -func (db *OfficeMgoDB) GetUserTags(ctx context.Context, userID string) ([]Tag, error) { - var tags []Tag +func (db *OfficeMgoDB) GetUserTags(ctx context.Context, userID string) ([]table.Tag, error) { + var tags []table.Tag cursor, err := db.TagCollection.Find(ctx, bson.M{"user_id": userID}) if err != nil { return tags, err @@ -85,7 +41,7 @@ func (db *OfficeMgoDB) GetUserTags(ctx context.Context, userID string) ([]Tag, e func (db *OfficeMgoDB) CreateTag(ctx context.Context, userID, tagName string, userList []string) error { tagID := generateTagID(tagName, userID) - tag := Tag{ + tag := table.Tag{ UserID: userID, TagID: tagID, TagName: tagName, @@ -95,8 +51,8 @@ func (db *OfficeMgoDB) CreateTag(ctx context.Context, userID, tagName string, us return err } -func (db *OfficeMgoDB) GetTagByID(ctx context.Context, userID, tagID string) (Tag, error) { - var tag Tag +func (db *OfficeMgoDB) GetTagByID(ctx context.Context, userID, tagID string) (table.Tag, error) { + var tag table.Tag err := db.TagCollection.FindOne(ctx, bson.M{"user_id": userID, "tag_id": tagID}).Decode(&tag) return tag, err } @@ -107,7 +63,7 @@ func (db *OfficeMgoDB) DeleteTag(ctx context.Context, userID, tagID string) erro } func (db *OfficeMgoDB) SetTag(ctx context.Context, userID, tagID, newName string, increaseUserIDList []string, reduceUserIDList []string) error { - var tag Tag + var tag table.Tag if err := db.TagCollection.FindOne(ctx, bson.M{"tag_id": tagID, "user_id": userID}).Decode(&tag); err != nil { return err } @@ -140,18 +96,18 @@ func (db *OfficeMgoDB) SetTag(ctx context.Context, userID, tagID, newName string } func (db *OfficeMgoDB) GetUserIDListByTagID(ctx context.Context, userID, tagID string) ([]string, error) { - var tag Tag + var tag table.Tag err := db.TagCollection.FindOne(ctx, bson.M{"user_id": userID, "tag_id": tagID}).Decode(&tag) return tag.UserList, err } -func (db *OfficeMgoDB) SaveTagSendLog(ctx context.Context, tagSendLog *TagSendLog) error { +func (db *OfficeMgoDB) SaveTagSendLog(ctx context.Context, tagSendLog *table.TagSendLog) error { _, err := db.TagSendLogCollection.InsertOne(ctx, tagSendLog) return err } -func (db *OfficeMgoDB) GetTagSendLogs(ctx context.Context, userID string, showNumber, pageNumber int32) ([]TagSendLog, error) { - var tagSendLogs []TagSendLog +func (db *OfficeMgoDB) GetTagSendLogs(ctx context.Context, userID string, showNumber, pageNumber int32) ([]table.TagSendLog, error) { + var tagSendLogs []table.TagSendLog findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"send_time": -1}) cursor, err := db.TagSendLogCollection.Find(ctx, bson.M{"send_id": userID}, findOpts) if err != nil { @@ -161,7 +117,7 @@ func (db *OfficeMgoDB) GetTagSendLogs(ctx context.Context, userID string, showNu return tagSendLogs, err } -func (db *OfficeMgoDB) CreateOneWorkMoment(ctx context.Context, workMoment *WorkMoment) error { +func (db *OfficeMgoDB) CreateOneWorkMoment(ctx context.Context, workMoment *table.WorkMoment) error { workMomentID := generateWorkMomentID(workMoment.UserID) workMoment.WorkMomentID = workMomentID workMoment.CreateTime = int32(time.Now().Unix()) @@ -184,13 +140,13 @@ func (db *OfficeMgoDB) DeleteComment(ctx context.Context, workMomentID, contentI return err } -func (db *OfficeMgoDB) GetWorkMomentByID(ctx context.Context, workMomentID string) (*WorkMoment, error) { - workMoment := &WorkMoment{} +func (db *OfficeMgoDB) GetWorkMomentByID(ctx context.Context, workMomentID string) (*table.WorkMoment, error) { + workMoment := &table.WorkMoment{} err := db.WorkMomentCollection.FindOne(ctx, bson.M{"work_moment_id": workMomentID}).Decode(workMoment) return workMoment, err } -func (db *OfficeMgoDB) LikeOneWorkMoment(ctx context.Context, likeUserID, userName, workMomentID string) (*WorkMoment, bool, error) { +func (db *OfficeMgoDB) LikeOneWorkMoment(ctx context.Context, likeUserID, userName, workMomentID string) (*table.WorkMoment, bool, error) { workMoment, err := db.GetWorkMomentByID(ctx, workMomentID) if err != nil { return nil, false, err @@ -203,7 +159,7 @@ func (db *OfficeMgoDB) LikeOneWorkMoment(ctx context.Context, likeUserID, userNa } } if !isAlreadyLike { - workMoment.LikeUserList = append(workMoment.LikeUserList, &commonUser{UserID: likeUserID, UserName: userName}) + workMoment.LikeUserList = append(workMoment.LikeUserList, &table.CommonUser{UserID: likeUserID, UserName: userName}) } _, err = db.WorkMomentCollection.UpdateOne(ctx, bson.M{"work_moment_id": workMomentID}, bson.M{"$set": bson.M{"like_user_list": workMoment.LikeUserList}}) return workMoment, !isAlreadyLike, err @@ -213,15 +169,15 @@ func (db *OfficeMgoDB) SetUserWorkMomentsLevel(ctx context.Context, userID strin return nil } -func (db *OfficeMgoDB) CommentOneWorkMoment(ctx context.Context, comment *Comment, workMomentID string) (WorkMoment, error) { +func (db *OfficeMgoDB) CommentOneWorkMoment(ctx context.Context, comment *table.Comment, workMomentID string) (table.WorkMoment, error) { comment.ContentID = generateWorkMomentCommentID(workMomentID) - var workMoment WorkMoment + var workMoment table.WorkMoment err := db.WorkMomentCollection.FindOneAndUpdate(ctx, bson.M{"work_moment_id": workMomentID}, bson.M{"$push": bson.M{"comments": comment}}).Decode(&workMoment) return workMoment, err } -func (db *OfficeMgoDB) GetUserSelfWorkMoments(ctx context.Context, userID string, showNumber, pageNumber int32) ([]WorkMoment, error) { - var workMomentList []WorkMoment +func (db *OfficeMgoDB) GetUserSelfWorkMoments(ctx context.Context, userID string, showNumber, pageNumber int32) ([]table.WorkMoment, error) { + var workMomentList []table.WorkMoment findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"create_time": -1}) result, err := db.WorkMomentCollection.Find(ctx, bson.M{"user_id": userID}, findOpts) if err != nil { @@ -231,8 +187,8 @@ func (db *OfficeMgoDB) GetUserSelfWorkMoments(ctx context.Context, userID string return workMomentList, err } -func (db *OfficeMgoDB) GetUserWorkMoments(ctx context.Context, opUserID, userID string, showNumber, pageNumber int32, friendIDList []string) ([]WorkMoment, error) { - var workMomentList []WorkMoment +func (db *OfficeMgoDB) GetUserWorkMoments(ctx context.Context, opUserID, userID string, showNumber, pageNumber int32, friendIDList []string) ([]table.WorkMoment, error) { + var workMomentList []table.WorkMoment findOpts := options.Find().SetLimit(int64(showNumber)).SetSkip(int64(showNumber) * (int64(pageNumber) - 1)).SetSort(bson.M{"create_time": -1}) result, err := db.WorkMomentCollection.Find(ctx, bson.D{ // 等价条件: select * from {"user_id", userID}, diff --git a/pkg/common/db/unrelation/super_group.go b/pkg/common/db/unrelation/super_group.go index 1ad8659d8..f4d99a25f 100644 --- a/pkg/common/db/unrelation/super_group.go +++ b/pkg/common/db/unrelation/super_group.go @@ -2,6 +2,7 @@ package unrelation import ( "Open_IM/pkg/common/config" + "Open_IM/pkg/common/db/table" "Open_IM/pkg/utils" "context" "go.mongodb.org/mongo-driver/bson" @@ -22,23 +23,13 @@ type SuperGroupMgoDB struct { userToSuperGroupCollection *mongo.Collection } -type SuperGroup struct { - GroupID string `bson:"group_id" json:"groupID"` - MemberIDList []string `bson:"member_id_list" json:"memberIDList"` -} - -type UserToSuperGroup struct { - UserID string `bson:"user_id" json:"userID"` - GroupIDList []string `bson:"group_id_list" json:"groupIDList"` -} - func NewSuperGroupMgoDB(mgoClient *mongo.Client) *SuperGroupMgoDB { mgoDB := mgoClient.Database(config.Config.Mongo.DBDatabase) return &SuperGroupMgoDB{MgoDB: mgoDB, MgoClient: mgoClient, superGroupCollection: mgoDB.Collection(cSuperGroup), userToSuperGroupCollection: mgoDB.Collection(cUserToSuperGroup)} } func (db *SuperGroupMgoDB) CreateSuperGroup(sCtx mongo.SessionContext, groupID string, initMemberIDList []string) error { - superGroup := SuperGroup{ + superGroup := table.SuperGroup{ GroupID: groupID, MemberIDList: initMemberIDList, } @@ -60,8 +51,8 @@ func (db *SuperGroupMgoDB) CreateSuperGroup(sCtx mongo.SessionContext, groupID s } -func (db *SuperGroupMgoDB) GetSuperGroup(ctx context.Context, groupID string) (*SuperGroup, error) { - superGroup := SuperGroup{} +func (db *SuperGroupMgoDB) GetSuperGroup(ctx context.Context, groupID string) (*table.SuperGroup, error) { + superGroup := table.SuperGroup{} err := db.superGroupCollection.FindOne(ctx, bson.M{"group_id": groupID}).Decode(&superGroup) return &superGroup, err } @@ -106,8 +97,8 @@ func (db *SuperGroupMgoDB) RemoverUserFromSuperGroup(ctx context.Context, groupI }) } -func (db *SuperGroupMgoDB) GetSuperGroupByUserID(ctx context.Context, userID string) (*UserToSuperGroup, error) { - var user UserToSuperGroup +func (db *SuperGroupMgoDB) GetSuperGroupByUserID(ctx context.Context, userID string) (*table.UserToSuperGroup, error) { + var user table.UserToSuperGroup err := db.userToSuperGroupCollection.FindOne(ctx, bson.M{"user_id": userID}).Decode(&user) return &user, utils.Wrap(err, "") } @@ -115,7 +106,7 @@ func (db *SuperGroupMgoDB) GetSuperGroupByUserID(ctx context.Context, userID str func (db *SuperGroupMgoDB) DeleteSuperGroup(ctx context.Context, groupID string) error { opts := options.Session().SetDefaultReadConcern(readconcern.Majority()) return db.MgoDB.Client().UseSessionWithOptions(ctx, opts, func(sCtx mongo.SessionContext) error { - superGroup := &SuperGroup{} + superGroup := &table.SuperGroup{} _, err := db.superGroupCollection.DeleteOne(sCtx, bson.M{"group_id": groupID}) if err != nil { _ = sCtx.AbortTransaction(ctx) From 848e861304bf22ffa93fe3a14dd6c1259999a761 Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Thu, 2 Feb 2023 10:28:52 +0800 Subject: [PATCH 8/8] errcode --- internal/rpc/group/group.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 88135d793..a7fab642a 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -43,8 +43,9 @@ type groupServer struct { etcdAddr []string controller.GroupInterface - userRpc pbUser.UserClient - conversationRpc pbConversation.ConversationClient + etcdConn *getcdv3.EtcdConn + //userRpc pbUser.UserClient + //conversationRpc pbConversation.ConversationClient } func NewGroupServer(port int) *groupServer { @@ -65,12 +66,12 @@ func NewGroupServer(port int) *groupServer { panic("NewEtcdConn failed" + err.Error()) } etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImUserName, config.Config.RpcPort.OpenImUserPort) - conn := etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImUserName) - g.userRpc = pbUser.NewUserClient(conn) + //conn := etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImUserName) + //g.userRpc = pbUser.NewUserClient(conn) etcdClient.SetDefaultEtcdConfig(config.Config.RpcRegisterName.OpenImConversationName, config.Config.RpcPort.OpenImConversationPort) - conn = etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImConversationName) - g.conversationRpc = pbConversation.NewConversationClient(conn) + //conn = etcdClient.GetConn("", config.Config.RpcRegisterName.OpenImConversationName) + //g.conversationRpc = pbConversation.NewConversationClient(conn) //mysql init var mysql relation.Mysql @@ -903,7 +904,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf conversation.GroupAtType = constant.GroupNotification conversationReq.UserIDList = cacheResp.UserIDList - _, err := s.conversationRpc.ModifyConversationField(ctx, &conversationReq) + _, err = pbConversation.NewConversationClient(s.etcdConn.GetConn("", config.Config.RpcRegisterName.OpenImConversationName)).ModifyConversationField(ctx, &conversationReq) tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) } return resp, nil