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

Error code standardization

Browse Source
This commit is contained in:
skiffer-git
2023-01-13 20:58:06 +08:00
parent 16c9f670cf
commit 87ce1895e3
7 changed files with 471 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/rpc/group/g.go
+22 -8
View File
@@ -5,8 +5,11 @@ import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/tools"
pbGroup "Open_IM/pkg/proto/group"
sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
"math/big"
"strconv"
"time"
)
@@ -19,16 +22,12 @@ func getDBGroupRequest(ctx context.Context, req *pbGroup.GroupApplicationRespons
return dbGroupRequest
}
func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (dbGroupMember *imdb.GroupMember) {
func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMember *imdb.GroupMember, err error) {
dbGroupMember = &imdb.GroupMember{}
utils.CopyStructFields(&dbGroupRequest, req)
dbGroupRequest.UserID = req.FromUserID
dbGroupRequest.HandleUserID = tools.OpUserID(ctx)
dbGroupRequest.HandledTime = time.Now()
member := imdb.GroupMember{}
member.GroupID = req.GroupID
member.UserID = req.FromUserID
member.GroupID = groupID
member.UserID = userID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = tools.OpUserID(ctx)
@@ -38,5 +37,20 @@ func getDBGroupMember(ctx context.Context, req *pbGroup.GroupApplicationResponse
member.InviterUserID = request.InviterUserID
member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
return dbGroupRequest
return dbGroupMember, nil
}
func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk.UserInfo, error) {
return nil, nil
}
func genGroupID(ctx context.Context, groupID string) string {
if groupID != "" {
return groupID
}
groupID = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
bi := big.NewInt(0)
bi.SetString(groupID[0:8], 16)
groupID = bi.String()
return groupID
}
internal/rpc/group/group.go
+23 -47
View File
@@ -24,7 +24,6 @@ import (
"Open_IM/pkg/utils"
"context"
"errors"
"math/big"
"net"
"strconv"
"strings"
@@ -121,48 +120,36 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
if err := token_verify.CheckAccessV3(ctx, req.OwnerUserID); err != nil {
return nil, err
}
var groupOwnerNum int
if req.OwnerUserID == "" {
return nil, constant.ErrArgs.Wrap("no group owner")
}
var userIDs []string
for _, info := range req.InitMemberList {
if info.RoleLevel == constant.GroupOwner {
groupOwnerNum++
}
userIDs = append(userIDs, info.UserID)
for _, ordinaryUserID := range req.InitMemberList {
userIDs = append(userIDs, ordinaryUserID)
}
if req.OwnerUserID != "" {
groupOwnerNum++
userIDs = append(userIDs, req.OwnerUserID)
userIDs = append(userIDs, req.OwnerUserID)
for _, adminUserID := range req.AdminUserIDs {
userIDs = append(userIDs, adminUserID)
}
if groupOwnerNum != 1 {
return nil, constant.ErrArgs.Wrap("groupOwnerNum != 1")
}
if utils.IsRepeatStringSlice(userIDs) {
if utils.IsRepeatID(userIDs) {
return nil, constant.ErrArgs.Wrap("group member is repeated")
}
users, err := rocksCache.GetUserInfoFromCacheBatch(ctx, userIDs)
users, err := getUsersInfo(ctx, userIDs)
if err != nil {
return nil, err
}
if len(users) != len(userIDs) {
return nil, constant.ErrDatabase.Wrap("len(users from cache) != len(userIDs)")
}
userMap := make(map[string]*imdb.User)
userMap := make(map[string]*open_im_sdk.UserInfo)
for i, user := range users {
userMap[user.UserID] = users[i]
}
if err := s.DelGroupAndUserCache(ctx, "", userIDs); err != nil {
return nil, err
}
if err := callbackBeforeCreateGroup(ctx, req); err != nil {
return nil, err
}
groupId := req.GroupInfo.GroupID
if groupId == "" {
groupId = utils.Md5(tools.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
bi := big.NewInt(0)
bi.SetString(groupId[0:8], 16)
groupId = bi.String()
}
groupId := genGroupID(ctx, req.GroupInfo.GroupID)
groupInfo := imdb.Group{}
utils.CopyStructFields(&groupInfo, req.GroupInfo)
groupInfo.CreatorUserID = tools.OpUserID(ctx)
@@ -171,7 +158,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
if groupInfo.NotificationUpdateTime.Unix() < 0 {
groupInfo.NotificationUpdateTime = utils.UnixSecondToTime(0)
}
if req.GroupInfo.GroupType != constant.SuperGroup {
var groupMembers []*imdb.GroupMember
joinGroup := func(userID string, roleLevel int32) error {
groupMember := &imdb.GroupMember{GroupID: groupId, RoleLevel: roleLevel, OperatorUserID: tools.OpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tools.OpUserID(ctx)}
@@ -193,9 +182,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, err
}
}
if err := (*imdb.GroupMember)(nil).Create(ctx, groupMembers); err != nil {
return nil, err
}
} else {
if err := db.DB.CreateSuperGroup(groupId, userIDs, len(userIDs)); err != nil {
return nil, err
@@ -673,30 +664,15 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err
}
if req.HandleResult == constant.GroupResponseAgree {
user, err := imdb.GetUserByUserID(req.FromUserID)
member, err := getDBGroupMember(ctx, req.GroupID, req.FromUserID)
if err != nil {
return nil, err
}
request, err := (&imdb.GroupRequest{}).Take(ctx, req.GroupID, req.FromUserID)
err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), member, groupInfo.Ex)
if err != nil {
return nil, err
}
member := imdb.GroupMember{}
member.GroupID = req.GroupID
member.UserID = req.FromUserID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = tools.OpUserID(ctx)
member.FaceURL = user.FaceURL
member.Nickname = user.Nickname
member.JoinSource = request.JoinSource
member.InviterUserID = request.InviterUserID
member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
err = CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &member, groupInfo.Ex)
if err != nil {
return nil, err
}
err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{&member})
err = (&imdb.GroupMember{}).Create(ctx, []*imdb.GroupMember{member})
if err != nil {
return nil, err
}
internal/utils/conversion.go
+224
View File
@@ -0,0 +1,224 @@
package utils
import (
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
sdk "Open_IM/pkg/proto/sdk_ws"
utils2 "Open_IM/pkg/utils"
utils "github.com/OpenIMSDK/open_utils"
"time"
)
func getUsersInfo(userIDs []string) ([]*sdk.UserInfo, error) {
return nil, nil
}
func getGroupOwnerInfo(groupID string) (*sdk.GroupMemberFullInfo, error) {
return nil, nil
}
func getNumberOfGroupMember(groupID string) (int32, error) {
return 0, nil
}
type DBFriend struct {
*imdb.Friend
}
type PBFriend struct {
*sdk.FriendInfo
}
func (db *DBFriend) convert() (*sdk.FriendInfo, error) {
pbFriend := &sdk.FriendInfo{FriendUser: &sdk.UserInfo{}}
utils.CopyStructFields(pbFriend, db)
user, err := getUsersInfo([]string{db.FriendUserID})
if err != nil {
return nil, err
}
utils2.CopyStructFields(pbFriend.FriendUser, user[0])
pbFriend.CreateTime = uint32(db.CreateTime.Unix())
pbFriend.FriendUser.CreateTime = uint32(db.CreateTime.Unix())
return pbFriend, nil
}
func (pb *PBFriend) convert() (*imdb.Friend, error) {
dbFriend := &imdb.Friend{}
utils2.CopyStructFields(dbFriend, pb)
dbFriend.FriendUserID = pb.FriendUser.UserID
dbFriend.CreateTime = utils2.UnixSecondToTime(int64(pb.CreateTime))
return dbFriend, nil
}
type DBFriendRequest struct {
*imdb.FriendRequest
}
type PBFriendRequest struct {
*sdk.FriendRequest
}
func (pb *PBFriendRequest) convert() (*imdb.FriendRequest, error) {
dbFriendRequest := &imdb.FriendRequest{}
utils.CopyStructFields(dbFriendRequest, pb)
dbFriendRequest.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
dbFriendRequest.HandleTime = utils.UnixSecondToTime(int64(pb.HandleTime))
return dbFriendRequest, nil
}
func (db *DBFriendRequest) convert() (*sdk.FriendRequest, error) {
pbFriendRequest := &sdk.FriendRequest{}
utils.CopyStructFields(pbFriendRequest, db)
user, err := getUsersInfo([]string{db.FromUserID})
if err != nil {
return nil, err
}
pbFriendRequest.FromNickname = user[0].Nickname
pbFriendRequest.FromFaceURL = user[0].FaceURL
pbFriendRequest.FromGender = user[0].Gender
user, err = getUsersInfo([]string{db.ToUserID})
if err != nil {
return nil, err
}
pbFriendRequest.ToNickname = user[0].Nickname
pbFriendRequest.ToFaceURL = user[0].FaceURL
pbFriendRequest.ToGender = user[0].Gender
pbFriendRequest.CreateTime = uint32(db.CreateTime.Unix())
pbFriendRequest.HandleTime = uint32(db.HandleTime.Unix())
return pbFriendRequest, nil
}
type DBBlack struct {
*imdb.Black
}
type PBBlack struct {
*sdk.BlackInfo
}
func (pb *PBBlack) convert() (*imdb.Black, error) {
dbBlack := &imdb.Black{}
dbBlack.BlockUserID = pb.BlackUserInfo.UserID
dbBlack.CreateTime = utils.UnixSecondToTime(int64(pb.CreateTime))
return dbBlack, nil
}
func (db *DBBlack) convert() (*sdk.BlackInfo, error) {
pbBlack := &sdk.BlackInfo{}
utils.CopyStructFields(pbBlack, db)
pbBlack.CreateTime = uint32(db.CreateTime.Unix())
user, err := getUsersInfo([]string{db.BlockUserID})
if err != nil {
return nil, err
}
utils.CopyStructFields(pbBlack.BlackUserInfo, user)
return pbBlack, nil
}
type DBGroup struct {
*imdb.Group
}
type PBGroup struct {
*sdk.GroupInfo
}
func (pb *PBGroup) convert() (*imdb.Group, error) {
dst := &imdb.Group{}
utils.CopyStructFields(dst, pb)
return dst, nil
}
func (db *DBGroup) convert() (*sdk.GroupInfo, error) {
dst := &sdk.GroupInfo{}
utils.CopyStructFields(dst, db)
user, err := getGroupOwnerInfo(db.GroupID)
if err != nil {
return nil, err
}
dst.OwnerUserID = user.UserID
memberCount, err := getNumberOfGroupMember(db.GroupID)
if err != nil {
return nil, err
}
dst.MemberCount = uint32(memberCount)
dst.CreateTime = uint32(db.CreateTime.Unix())
dst.NotificationUpdateTime = uint32(db.NotificationUpdateTime.Unix())
if db.NotificationUpdateTime.Unix() < 0 {
dst.NotificationUpdateTime = 0
}
return dst, nil
}
type DBGroupMember struct {
*imdb.GroupMember
}
type PBGroupMember struct {
*sdk.GroupMemberFullInfo
}
func (pb *PBGroupMember) convert() (*imdb.GroupMember, error) {
dst := &imdb.GroupMember{}
utils.CopyStructFields(dst, pb)
dst.JoinTime = utils.UnixSecondToTime(int64(pb.JoinTime))
dst.MuteEndTime = utils.UnixSecondToTime(int64(pb.MuteEndTime))
return dst, nil
}
func (db *DBGroupMember) convert() (*sdk.GroupMemberFullInfo, error) {
dst := &sdk.GroupMemberFullInfo{}
utils.CopyStructFields(dst, db)
user, err := getUsersInfo([]string{db.UserID})
if err != nil {
return nil, err
}
dst.AppMangerLevel = user[0].AppMangerLevel
dst.JoinTime = int32(db.JoinTime.Unix())
if db.JoinTime.Unix() < 0 {
dst.JoinTime = 0
}
dst.MuteEndTime = uint32(db.MuteEndTime.Unix())
if dst.MuteEndTime < uint32(time.Now().Unix()) {
dst.MuteEndTime = 0
}
return dst, nil
}
type DBGroupRequest struct {
*imdb.GroupRequest
}
type PBGroupRequest struct {
*sdk.GroupRequest
}
func (pb *PBGroupRequest) convert() (*imdb.GroupRequest, error) {
dst := &imdb.GroupRequest{}
utils.CopyStructFields(dst, pb)
dst.ReqTime = utils.UnixSecondToTime(int64(pb.ReqTime))
dst.HandledTime = utils.UnixSecondToTime(int64(pb.HandleTime))
return dst, nil
}
func (db *DBGroupRequest) convert() (*sdk.GroupRequest, error) {
dst := &sdk.GroupRequest{}
utils.CopyStructFields(dst, db)
dst.ReqTime = uint32(db.ReqTime.Unix())
dst.HandleTime = uint32(db.HandledTime.Unix())
return dst, nil
}
func UserOpenIMCopyDB(dst *imdb.User, src *open_im_sdk.UserInfo) {
utils.CopyStructFields(dst, src)
dst.Birth, _ = utils.TimeStringToTime(src.BirthStr)
dst.CreateTime = utils.UnixSecondToTime(int64(src.CreateTime))
}
func UserDBCopyOpenIM(dst *open_im_sdk.UserInfo, src *imdb.User) {
utils.CopyStructFields(dst, src)
dst.CreateTime = uint32(src.CreateTime.Unix())
//dst.Birth = uint32(src.Birth.Unix())
dst.BirthStr = utils2.TimeToString(src.Birth)
}
func UserDBCopyOpenIMPublicUser(dst *open_im_sdk.PublicUserInfo, src *imdb.User) {
utils.CopyStructFields(dst, src)
}