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

error

Browse Source
This commit is contained in:
withchao
2023-03-07 12:19:30 +08:00
parent 3fe9ee22fe
commit 4c5613084c
40 changed files with 315 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/rpc/auth/auth.go
+6 -5
View File
@@ -10,6 +10,7 @@ import (
"OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog"
discoveryRegistry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbAuth "OpenIM/pkg/proto/auth"
"OpenIM/pkg/proto/msggateway"
"OpenIM/pkg/utils"
@@ -60,19 +61,19 @@ func (s *authServer) parseToken(ctx context.Context, tokensString string) (claim
return nil, err
}
if len(m) == 0 {
return nil, constant.ErrTokenNotExist.Wrap()
return nil, errs.ErrTokenNotExist.Wrap()
}
if v, ok := m[tokensString]; ok {
switch v {
case constant.NormalToken:
return claims, nil
case constant.KickedToken:
return nil, constant.ErrTokenKicked.Wrap()
return nil, errs.ErrTokenKicked.Wrap()
default:
return nil, utils.Wrap(constant.ErrTokenUnknown, "")
return nil, utils.Wrap(errs.ErrTokenUnknown, "")
}
}
return nil, constant.ErrTokenNotExist.Wrap()
return nil, errs.ErrTokenNotExist.Wrap()
}
func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
@@ -110,5 +111,5 @@ func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID
_, err := client.KickUserOffline(ctx, kickReq)
return utils.Wrap(err, "")
}
return constant.ErrInternalServer.Wrap()
return errs.ErrInternalServer.Wrap()
}
internal/rpc/friend/friend.go
+8 -7
View File
@@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog"
registry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbfriend "OpenIM/pkg/proto/friend"
"OpenIM/pkg/utils"
"context"
@@ -50,11 +51,11 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
return nil, err
}
if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
if req.ToUserID == req.FromUserID {
return nil, constant.ErrCanNotAddYourself.Wrap()
return nil, errs.ErrCanNotAddYourself.Wrap()
}
if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil {
return nil, err
@@ -64,7 +65,7 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
return nil, err
}
if in1 && in2 {
return nil, constant.ErrRelationshipAlready.Wrap()
return nil, errs.ErrRelationshipAlready.Wrap()
}
if err = s.FriendDatabase.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
return nil, err
@@ -84,10 +85,10 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFr
}
if utils.Contain(req.OwnerUserID, req.FriendUserIDs...) {
return nil, constant.ErrCanNotAddYourself.Wrap()
return nil, errs.ErrCanNotAddYourself.Wrap()
}
if utils.Duplicate(req.FriendUserIDs) {
return nil, constant.ErrArgs.Wrap("friend userID repeated")
return nil, errs.ErrArgs.Wrap("friend userID repeated")
}
if err := s.FriendDatabase.BecomeFriends(ctx, req.OwnerUserID, req.FriendUserIDs, constant.BecomeFriendByImport, tracelog.GetOpUserID(ctx)); err != nil {
@@ -119,7 +120,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.Res
s.notification.FriendApplicationRefusedNotification(ctx, req)
return resp, nil
}
return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1")
return nil, errs.ErrArgs.Wrap("req.HandleResult != -1/1")
}
// ok
@@ -162,7 +163,7 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.G
resp = &pbfriend.GetDesignatedFriendsResp{}
if utils.Duplicate(req.FriendUserIDs) {
return nil, constant.ErrArgs.Wrap("friend userID repeated")
return nil, errs.ErrArgs.Wrap("friend userID repeated")
}
friends, err := s.FriendDatabase.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
if err != nil {
internal/rpc/group/group.go
+59 -58
View File
@@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog"
"OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbConversation "OpenIM/pkg/proto/conversation"
pbGroup "OpenIM/pkg/proto/group"
"OpenIM/pkg/proto/sdkws"
@@ -65,7 +66,7 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
return err
}
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return constant.ErrNoPermission.Wrap("no group owner or admin")
return errs.ErrNoPermission.Wrap("no group owner or admin")
}
}
return nil
@@ -92,7 +93,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
if *groupID != "" {
_, err := s.GroupDatabase.TakeGroup(ctx, *groupID)
if err == nil {
return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
return errs.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
} else if s.IsNotFound(err) {
return nil
} else {
@@ -114,7 +115,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
return err
}
}
return constant.ErrData.Wrap("group id gen error")
return errs.ErrData.Wrap("group id gen error")
}
func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
@@ -123,17 +124,17 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, err
}
if req.OwnerUserID == "" {
return nil, constant.ErrArgs.Wrap("no group owner")
return nil, errs.ErrArgs.Wrap("no group owner")
}
userIDs := append(append(req.InitMembers, req.AdminUserIDs...), req.OwnerUserID)
if utils.Duplicate(userIDs) {
return nil, constant.ErrArgs.Wrap("group member repeated")
return nil, errs.ErrArgs.Wrap("group member repeated")
}
userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true)
if err != nil {
return nil, err
}
if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
var groupMembers []*relationTb.GroupMemberModel
@@ -149,7 +150,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
groupMember.JoinSource = constant.JoinByInvitation
groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return err
}
groupMembers = append(groupMembers, groupMember)
@@ -233,17 +234,17 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
resp := &pbGroup.InviteUserToGroupResp{}
if len(req.InvitedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("user empty")
return nil, errs.ErrArgs.Wrap("user empty")
}
if utils.Duplicate(req.InvitedUserIDs) {
return nil, constant.ErrArgs.Wrap("userID duplicate")
return nil, errs.ErrArgs.Wrap("userID duplicate")
}
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
if err != nil {
return nil, err
}
if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrDismissedAlready.Wrap()
return nil, errs.ErrDismissedAlready.Wrap()
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{group.GroupID}, nil, nil)
if err != nil {
@@ -253,7 +254,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
return e.UserID
})
if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
return nil, errs.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
}
userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
if err != nil {
@@ -264,7 +265,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
opUserID := tracelog.GetOpUserID(ctx)
member, ok := memberMap[opUserID]
if !ok {
return nil, constant.ErrNoPermission.Wrap("not in group")
return nil, errs.ErrNoPermission.Wrap("not in group")
}
if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
var requests []*relationTb.GroupRequestModel
@@ -309,7 +310,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
member.OperatorUserID = opUserID
member.InviterUserID = opUserID
member.JoinSource = constant.JoinByInvitation
if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
groupMembers = append(groupMembers, member)
@@ -329,7 +330,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
return nil, err
}
if group.GroupType == constant.SuperGroup {
return nil, constant.ErrArgs.Wrap("unsupported super group")
return nil, errs.ErrArgs.Wrap("unsupported super group")
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, nil)
if err != nil {
@@ -379,14 +380,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
return nil, err
}
if len(req.KickedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("KickedUserIDs empty")
return nil, errs.ErrArgs.Wrap("KickedUserIDs empty")
}
if utils.IsDuplicateStringSlice(req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("KickedUserIDs duplicate")
return nil, errs.ErrArgs.Wrap("KickedUserIDs duplicate")
}
opUserID := tracelog.GetOpUserID(ctx)
if utils.IsContain(opUserID, req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("opUserID in KickedUserIDs")
return nil, errs.ErrArgs.Wrap("opUserID in KickedUserIDs")
}
if group.GroupType == constant.SuperGroup {
if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, req.KickedUserIDs); err != nil {
@@ -408,13 +409,13 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
}
for _, userID := range req.KickedUserIDs {
if _, ok := memberMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID)
return nil, errs.ErrUserIDNotFound.Wrap(userID)
}
}
if !tokenverify.IsAppManagerUid(ctx) {
member := memberMap[opUserID]
if member == nil {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
}
switch member.RoleLevel {
case constant.GroupOwner:
@@ -424,11 +425,11 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
continue
}
if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
return nil, constant.ErrNoPermission.Wrap("userID:" + member.UserID)
return nil, errs.ErrNoPermission.Wrap("userID:" + member.UserID)
}
}
default:
return nil, constant.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
return nil, errs.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
}
}
if err := s.GroupDatabase.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
@@ -442,10 +443,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
resp := &pbGroup.GetGroupMembersInfoResp{}
if len(req.Members) == 0 {
return nil, constant.ErrArgs.Wrap("members empty")
return nil, errs.ErrArgs.Wrap("members empty")
}
if req.GroupID == "" {
return nil, constant.ErrArgs.Wrap("groupID empty")
return nil, errs.ErrArgs.Wrap("groupID empty")
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, req.Members, nil)
if err != nil {
@@ -498,7 +499,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
return e.GroupID
})
if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
}
groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil {
@@ -520,7 +521,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
resp := &pbGroup.GetGroupsInfoResp{}
if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupID is empty")
return nil, errs.ErrArgs.Wrap("groupID is empty")
}
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil {
@@ -546,7 +547,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
resp := &pbGroup.GroupApplicationResponseResp{}
if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
return nil, constant.ErrArgs.Wrap("HandleResult unknown")
return nil, errs.ErrArgs.Wrap("HandleResult unknown")
}
if !tokenverify.IsAppManagerUid(ctx) {
groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID)
@@ -554,7 +555,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err
}
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return nil, constant.ErrNoPermission.Wrap("no group owner or admin")
return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
}
}
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
@@ -566,7 +567,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err
}
if groupRequest.HandleResult != 0 {
return nil, constant.ErrArgs.Wrap("group request already processed")
return nil, errs.ErrArgs.Wrap("group request already processed")
}
var join bool
if _, err = s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
@@ -592,7 +593,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
OperatorUserID: tracelog.GetOpUserID(ctx),
Ex: groupRequest.Ex,
}
if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue {
if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
}
@@ -620,11 +621,11 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return nil, err
}
if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrDismissedAlready.Wrap()
return nil, errs.ErrDismissedAlready.Wrap()
}
if group.NeedVerification == constant.Directly {
if group.GroupType == constant.SuperGroup {
return nil, constant.ErrGroupTypeNotSupport.Wrap()
return nil, errs.ErrGroupTypeNotSupport.Wrap()
}
user, err := s.UserCheck.GetUserInfo(ctx, tracelog.GetOpUserID(ctx))
if err != nil {
@@ -636,7 +637,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
groupMember.JoinSource = constant.JoinByInvitation
groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
if err := s.GroupDatabase.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
@@ -688,7 +689,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return nil, err
}
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return nil, constant.ErrNoPermission.Wrap("no group owner or admin")
return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
}
}
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
@@ -696,7 +697,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return nil, err
}
if group.Status == constant.GroupStatusDismissed {
return nil, utils.Wrap(constant.ErrDismissedAlready, "")
return nil, utils.Wrap(errs.ErrDismissedAlready, "")
}
userIDs, err := s.GroupDatabase.FindGroupMemberUserID(ctx, group.GroupID)
if err != nil {
@@ -739,10 +740,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
return nil, err
}
if group.Status == constant.GroupStatusDismissed {
return nil, utils.Wrap(constant.ErrDismissedAlready, "")
return nil, utils.Wrap(errs.ErrDismissedAlready, "")
}
if req.OldOwnerUserID == req.NewOwnerUserID {
return nil, constant.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID")
return nil, errs.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID")
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{req.OldOwnerUserID, req.NewOwnerUserID}, nil)
if err != nil {
@@ -750,11 +751,11 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
}
memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string { return e.UserID })
if ids := utils.Single([]string{req.OldOwnerUserID, req.NewOwnerUserID}, utils.Keys(memberMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
return nil, errs.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
}
newOwner := memberMap[req.NewOwnerUserID]
if newOwner == nil {
return nil, constant.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID)
return nil, errs.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID)
}
oldOwner := memberMap[req.OldOwnerUserID]
if tokenverify.IsAppManagerUid(ctx) {
@@ -766,10 +767,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
}
} else {
if oldOwner == nil {
return nil, constant.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
return nil, errs.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
}
if oldOwner.GroupID != tracelog.GetOpUserID(ctx) {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
}
}
if err := s.GroupDatabase.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
@@ -805,7 +806,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
return e.GroupID
})
if ids := utils.Single(groupIDs, utils.Keys(ownerMemberMap)); len(ids) > 0 {
return nil, constant.ErrDB.Wrap("group not owner " + strings.Join(ids, ","))
return nil, errs.ErrDatabase.Wrap("group not owner " + strings.Join(ids, ","))
}
groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil {
@@ -865,7 +866,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
return e.GroupID
})
if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
}
owners, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner})
if err != nil {
@@ -875,7 +876,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
return e.GroupID
})
if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap("group no owner", strings.Join(ids, ","))
return nil, errs.ErrData.Wrap("group no owner", strings.Join(ids, ","))
}
groupMemberNum, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil {
@@ -897,7 +898,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
return nil, err
}
if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrArgs.Wrap("group status is dismissed")
return nil, errs.ErrArgs.Wrap("group status is dismissed")
}
if err := s.GroupDatabase.DismissGroup(ctx, req.GroupID); err != nil {
return nil, err
@@ -924,7 +925,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
return nil, err
}
if opMember.RoleLevel <= member.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
}
}
data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds)))
@@ -947,7 +948,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
return nil, err
}
if opMember.RoleLevel <= member.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
}
}
data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0))
@@ -985,7 +986,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) {
resp := &pbGroup.SetGroupMemberInfoResp{}
if len(req.Members) == 0 {
return nil, constant.ErrArgs.Wrap("members empty")
return nil, errs.ErrArgs.Wrap("members empty")
}
duplicateMap := make(map[[2]string]struct{})
userIDMap := make(map[string]struct{})
@@ -993,7 +994,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
for _, member := range req.Members {
key := [...]string{member.GroupID, member.UserID}
if _, ok := duplicateMap[key]; ok {
return nil, constant.ErrArgs.Wrap("group user duplicate")
return nil, errs.ErrArgs.Wrap("group user duplicate")
}
duplicateMap[key] = struct{}{}
userIDMap[member.UserID] = struct{}{}
@@ -1009,7 +1010,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
delete(duplicateMap, [...]string{member.GroupID, member.UserID})
}
if len(duplicateMap) > 0 {
return nil, constant.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
return nil, errs.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
return fmt.Sprintf("[group: %s user: %s]", e[0], e[1])
}), ","))
}
@@ -1024,10 +1025,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
}
opMember, ok := memberMap[[...]string{member.GroupID, member.UserID}]
if !ok {
return nil, constant.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID))
return nil, errs.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID))
}
if member.RoleLevel >= opMember.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel))
return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel))
}
}
}
@@ -1036,7 +1037,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
continue
}
if memberMap[[...]string{member.GroupID, member.UserID}].RoleLevel == constant.GroupOwner {
return nil, constant.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID))
return nil, errs.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID))
}
}
for i := 0; i < len(req.Members); i++ {
@@ -1063,10 +1064,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) {
resp := &pbGroup.GetGroupAbstractInfoResp{}
if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty")
return nil, errs.ErrArgs.Wrap("groupIDs empty")
}
if utils.Duplicate(req.GroupIDs) {
return nil, constant.ErrArgs.Wrap("groupIDs duplicate")
return nil, errs.ErrArgs.Wrap("groupIDs duplicate")
}
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil {
@@ -1075,14 +1076,14 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
if ids := utils.Single(req.GroupIDs, utils.Slice(groups, func(group *relationTb.GroupModel) string {
return group.GroupID
})); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ","))
return nil, errs.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ","))
}
groupUserMap, err := s.GroupDatabase.MapGroupMemberUserID(ctx, req.GroupIDs)
if err != nil {
return nil, err
}
if ids := utils.Single(req.GroupIDs, utils.Keys(groupUserMap)); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ",")))
return nil, errs.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ",")))
}
resp.GroupAbstractInfos = utils.Slice(groups, func(group *relationTb.GroupModel) *pbGroup.GroupAbstractInfo {
users := groupUserMap[group.GroupID]
@@ -1094,7 +1095,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.GetUserInGroupMembersReq) (*pbGroup.GetUserInGroupMembersResp, error) {
resp := &pbGroup.GetUserInGroupMembersResp{}
if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty")
return nil, errs.ErrArgs.Wrap("groupIDs empty")
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.UserID}, req.GroupIDs, nil)
if err != nil {
@@ -1127,7 +1128,7 @@ func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbGroup.Ge
func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
resp := &pbGroup.GetGroupMemberRoleLevelResp{}
if len(req.RoleLevels) == 0 {
return nil, constant.ErrArgs.Wrap("RoleLevels empty")
return nil, errs.ErrArgs.Wrap("RoleLevels empty")
}
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels)
if err != nil {
internal/rpc/group/super_group.go
+4 -3
View File
@@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/db/table/relation"
"OpenIM/pkg/common/db/table/unrelation"
"OpenIM/pkg/errs"
pbGroup "OpenIM/pkg/proto/group"
sdkws "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils"
@@ -29,7 +30,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return e.GroupID
})
if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
return nil, errs.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
}
groups, err := s.GroupDatabase.FindGroup(ctx, joinSuperGroup.GroupIDs)
if err != nil {
@@ -39,7 +40,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return e.GroupID
})
if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(groupMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
return nil, errs.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
}
superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, joinSuperGroup.GroupIDs)
if err != nil {
@@ -57,7 +58,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
resp = &pbGroup.GetSuperGroupsInfoResp{}
if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty")
return nil, errs.ErrArgs.Wrap("groupIDs empty")
}
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil {
internal/rpc/msg/send_msg.go
+12 -11
View File
@@ -3,6 +3,7 @@ package msg
import (
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/msg"
"OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils"
@@ -80,7 +81,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err
}
if black {
return nil, constant.ErrBlockedByPeer.Wrap()
return nil, errs.ErrBlockedByPeer.Wrap()
}
if *config.Config.MessageVerify.FriendVerify {
friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID)
@@ -88,7 +89,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err
}
if !friend {
return nil, constant.ErrNotPeersFriend.Wrap()
return nil, errs.ErrNotPeersFriend.Wrap()
}
return nil, nil
}
@@ -108,14 +109,14 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil
}
if !utils.IsContain(data.MsgData.SendID, userIDList) {
return nil, constant.ErrNotInGroupYet.Wrap()
return nil, errs.ErrNotInGroupYet.Wrap()
}
isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
if err != nil {
return nil, err
}
if isMute {
return nil, constant.ErrMutedInGroup.Wrap()
return nil, errs.ErrMutedInGroup.Wrap()
}
isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -127,7 +128,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
}
if isMute {
return nil, constant.ErrMutedGroup.Wrap()
return nil, errs.ErrMutedGroup.Wrap()
}
return userIDList, nil
case constant.SuperGroupChatType:
@@ -139,7 +140,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
revokeMessage := new(MessageRevoked)
err := utils.JsonStringToStruct(string(data.MsgData.Content), revokeMessage)
if err != nil {
return nil, constant.ErrArgs.Wrap()
return nil, errs.ErrArgs.Wrap()
}
if revokeMessage.RevokerID != revokeMessage.SourceMessageSendID {
@@ -153,7 +154,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
revokeMessage.SourceMessageSendID = resp[0].SendID
data.MsgData.Content = []byte(utils.StructToJsonString(revokeMessage))
} else {
return nil, constant.ErrData.Wrap("MsgData")
return nil, errs.ErrData.Wrap("MsgData")
}
}
}
@@ -172,7 +173,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil
} else {
if !utils.IsContain(data.MsgData.SendID, userIDList) {
return nil, constant.ErrNotInGroupYet.Wrap()
return nil, errs.ErrNotInGroupYet.Wrap()
}
}
isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -180,7 +181,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err
}
if isMute {
return nil, constant.ErrMutedInGroup.Wrap()
return nil, errs.ErrMutedInGroup.Wrap()
}
isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@@ -191,7 +192,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil
}
if isMute {
return nil, constant.ErrMutedGroup.Wrap()
return nil, errs.ErrMutedGroup.Wrap()
}
return userIDList, nil
@@ -328,7 +329,7 @@ func (m *msgServer) sendMsgToGroupOptimization(ctx context.Context, list []strin
}
if isSend {
if v == "" || groupPB.MsgData.SendID == "" {
return constant.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty")
return errs.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty")
}
err := m.MsgDatabase.MsgToMQ(ctx, v, &msgToMQGroup)
if err != nil {
internal/rpc/msg/send_pull.go
+12 -11
View File
@@ -3,6 +3,7 @@ package msg
import (
"OpenIM/pkg/common/constant"
promePkg "OpenIM/pkg/common/prome"
"OpenIM/pkg/errs"
pbConversation "OpenIM/pkg/proto/conversation"
"OpenIM/pkg/proto/msg"
"OpenIM/pkg/proto/sdkws"
@@ -16,7 +17,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
resp = &msg.SendMsgResp{}
promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
// callback
if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
@@ -30,7 +31,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
return nil, err
}
// callback
if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
@@ -62,7 +63,7 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq
func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
_, err = m.messageVerification(ctx, req)
@@ -77,17 +78,17 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq)
if isSend {
err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle)
if err != nil {
return nil, constant.ErrInternalServer.Wrap("insert to mq")
return nil, errs.ErrInternalServer.Wrap("insert to mq")
}
}
if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle)
if err != nil {
return nil, constant.ErrInternalServer.Wrap("insert to mq")
return nil, errs.ErrInternalServer.Wrap("insert to mq")
}
}
err = CallbackAfterSendSingleMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue {
if err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
promePkg.Inc(promePkg.SingleChatMsgProcessSuccessCounter)
@@ -103,7 +104,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
// callback
promePkg.Inc(promePkg.GroupChatMsgRecvSuccessCounter)
err = CallbackBeforeSendGroupMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue {
if err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
@@ -168,7 +169,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
// callback
err = CallbackAfterSendGroupMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue {
if err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
@@ -235,10 +236,10 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
resp = &msg.SendMsgResp{}
flag := isMessageHasReadEnabled(req.MsgData)
if !flag {
return nil, constant.ErrMessageHasReadDisable.Wrap()
return nil, errs.ErrMessageHasReadDisable.Wrap()
}
m.encapsulateMsgData(req.MsgData)
if err := CallbackMsgModify(ctx, req); err != nil && err != constant.ErrCallbackContinue {
if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err
}
switch req.MsgData.SessionType {
@@ -251,7 +252,7 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
case constant.SuperGroupChatType:
return m.sendMsgSuperGroupChat(ctx, req)
default:
return nil, constant.ErrArgs.Wrap("unknown sessionType")
return nil, errs.ErrArgs.Wrap("unknown sessionType")
}
}
internal/rpc/user/user.go
+5 -4
View File
@@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog"
registry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/sdkws"
pbuser "OpenIM/pkg/proto/user"
"OpenIM/pkg/utils"
@@ -38,7 +39,7 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
}
users := make([]*tablerelation.UserModel, 0)
if len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname) {
return constant.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
return errs.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
}
for k, v := range config.Config.Manager.AppManagerUid {
users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k]})
@@ -114,7 +115,7 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) {
resp = &pbuser.AccountCheckResp{}
if utils.Duplicate(req.CheckUserIDs) {
return nil, constant.ErrArgs.Wrap("userID repeated")
return nil, errs.ErrArgs.Wrap("userID repeated")
}
err = tokenverify.CheckAdmin(ctx)
if err != nil {
@@ -156,7 +157,7 @@ func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPagi
func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) {
resp = &pbuser.UserRegisterResp{}
if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) {
return nil, constant.ErrArgs.Wrap("userID repeated")
return nil, errs.ErrArgs.Wrap("userID repeated")
}
userIDs := make([]string, 0)
for _, v := range req.Users {
@@ -167,7 +168,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
return nil, err
}
if exist {
return nil, constant.ErrRegisteredAlready.Wrap("userID registered already")
return nil, errs.ErrRegisteredAlready.Wrap("userID registered already")
}
users, err := (*convert.PBUser)(nil).PB2DB(req.Users)
if err != nil {