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

1

Browse Source
test-errcode
withchao 3 years ago
parent 16fa05f76e
commit 0a81dd040f
4 changed files with 111 additions and 100 deletions
Show Stats Download Patch File Download Diff File

16
internal/rpc/group/g.go
Unescape View File

@ -5,7 +5,7 @@ import (
relation "Open_IM/pkg/common/db/mysql" relation "Open_IM/pkg/common/db/mysql"
"Open_IM/pkg/common/tools" "Open_IM/pkg/common/tools"
pbGroup "Open_IM/pkg/proto/group" pbGroup "Open_IM/pkg/proto/group"
sdk "Open_IM/pkg/proto/sdk_ws" sdk_ws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"math/big" "math/big"
@ -40,10 +40,22 @@ func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMembe
return dbGroupMember, nil return dbGroupMember, nil
} }
func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk.UserInfo, error) { func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.UserInfo, error) {
return nil, nil return nil, nil
} }
func getUserMap(ctx context.Context, userIDs []string) (map[string]*sdk_ws.UserInfo, error) {
users, err := getUsersInfo(ctx, userIDs)
if err != nil {
return nil, err
}
userMap := make(map[string]*sdk_ws.UserInfo)
for i, user := range users {
userMap[user.UserID] = users[i]
}
return userMap, nil
}
func genGroupID(ctx context.Context, groupID string) string { func genGroupID(ctx context.Context, groupID string) string {
if groupID != "" { if groupID != "" {
return groupID return groupID

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

@ -25,13 +25,12 @@ import (
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"errors" "errors"
grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
"net" "net"
"strconv" "strconv"
"strings" "strings"
"time" "time"
grpcPrometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
"google.golang.org/grpc" "google.golang.org/grpc"
"google.golang.org/protobuf/types/known/wrapperspb" "google.golang.org/protobuf/types/known/wrapperspb"
"gorm.io/gorm" "gorm.io/gorm"
@ -259,139 +258,128 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
groupNode.NotificationUpdateTime = group.NotificationUpdateTime.UnixMilli() groupNode.NotificationUpdateTime = group.NotificationUpdateTime.UnixMilli()
resp.GroupList = append(resp.GroupList, &groupNode) resp.GroupList = append(resp.GroupList, &groupNode)
} }
resp.Total = uint32(len(resp.GroupList)) resp.Total = int32(len(resp.GroupList))
return resp, nil return resp, nil
} }
func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) { func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
resp := &pbGroup.InviteUserToGroupResp{} resp := &pbGroup.InviteUserToGroupResp{}
opUserID := tools.OpUserID(ctx) if len(req.InvitedUserIDList) == 0 {
if err := token_verify.CheckManagerUserID(ctx, opUserID); err != nil { return nil, constant.ErrArgs.Wrap("user empty")
if err := relation.CheckIsExistGroupMember(ctx, req.GroupID, opUserID); err != nil {
return nil, err
} }
if utils.IsDuplicateID(req.InvitedUserIDList) {
return nil, constant.ErrArgs.Wrap("userID duplicate")
} }
groupInfo, err := (*relation.Group)(nil).Take(ctx, req.GroupID) group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if groupInfo.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, utils.Wrap(constant.ErrDismissedAlready, "") return nil, constant.ErrDismissedAlready.Wrap()
} }
if groupInfo.NeedVerification == constant.AllNeedVerification && members, err := s.GroupInterface.GetGroupMemberList(ctx, group.GroupID)
!relation.IsGroupOwnerAdmin(req.GroupID, tools.OpUserID(ctx)) && !token_verify.IsManagerUserID(tools.OpUserID(ctx)) {
joinReq := pbGroup.JoinGroupReq{}
for _, v := range req.InvitedUserIDList {
var groupRequest relation.GroupRequest
groupRequest.UserID = v
groupRequest.GroupID = req.GroupID
groupRequest.JoinSource = constant.JoinByInvitation
groupRequest.InviterUserID = tools.OpUserID(ctx)
err = relation.InsertIntoGroupRequest(groupRequest)
if err != nil { if err != nil {
var resultNode pbGroup.Id2Result return nil, err
resultNode.Result = -1
resultNode.UserID = v
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue
} else {
var resultNode pbGroup.Id2Result
resultNode.Result = 0
resultNode.UserID = v
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
joinReq.GroupID = req.GroupID
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
chat.JoinGroupApplicationNotification(ctx, &joinReq)
} }
memberMap := make(map[string]*relation.GroupMember)
for i, member := range members {
memberMap[member.GroupID] = members[i]
} }
return resp, nil for _, userID := range req.InvitedUserIDList {
if _, ok := memberMap[userID]; ok {
return nil, constant.ErrArgs.Wrap("user in group " + userID)
} }
if err := s.DelGroupAndUserCache(ctx, req.GroupID, req.InvitedUserIDList); err != nil { }
userMap, err := getUserMap(ctx, req.InvitedUserIDList)
if err != nil {
return nil, err return nil, err
} }
//from User: invite: applicant for _, userID := range req.InvitedUserIDList {
//to user: invite: invited if _, ok := userMap[userID]; !ok {
var okUserIDList []string return nil, constant.ErrUserIDNotFound.Wrap(userID)
if groupInfo.GroupType != constant.SuperGroup {
for _, v := range req.InvitedUserIDList {
var resultNode pbGroup.Id2Result
resultNode.UserID = v
resultNode.Result = 0
toUserInfo, err := relation.GetUserByUserID(v)
if err != nil {
trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue
} }
if relation.IsExistGroupMember(req.GroupID, v) {
trace_log.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v)
resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue
} }
var toInsertInfo relation.GroupMember if group.NeedVerification == constant.AllNeedVerification {
utils.CopyStructFields(&toInsertInfo, toUserInfo) if !token_verify.IsAppManagerUid(ctx) {
toInsertInfo.GroupID = req.GroupID opUserID := tools.OpUserID(ctx)
toInsertInfo.RoleLevel = constant.GroupOrdinaryUsers member, ok := memberMap[opUserID]
toInsertInfo.OperatorUserID = tools.OpUserID(ctx) if ok {
toInsertInfo.InviterUserID = tools.OpUserID(ctx) return nil, constant.ErrNoPermission.Wrap("not in group")
toInsertInfo.JoinSource = constant.JoinByInvitation }
if err := CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &toInsertInfo, groupInfo.Ex); err != nil { if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
var requests []*relation.GroupRequest
for _, userID := range req.InvitedUserIDList {
requests = append(requests, &relation.GroupRequest{
UserID: userID,
GroupID: req.GroupID,
JoinSource: constant.JoinByInvitation,
InviterUserID: opUserID,
})
}
if err := s.GroupInterface.CreateGroupRequest(ctx, requests); err != nil {
return nil, err return nil, err
} }
err = relation.InsertIntoGroupMember(toInsertInfo) for _, request := range requests {
if err != nil { chat.JoinGroupApplicationNotification(ctx, &pbGroup.JoinGroupReq{
trace_log.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo) GroupID: request.GroupID,
resultNode.Result = -1 ReqMessage: request.ReqMsg,
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) JoinSource: request.JoinSource,
continue InviterUserID: request.InviterUserID,
})
} }
okUserIDList = append(okUserIDList, v) return resp, nil
err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID)
if err != nil {
trace_log.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID)
} }
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
} }
} else { }
okUserIDList = req.InvitedUserIDList if group.GroupType == constant.SuperGroup {
if err := db.DB.AddUserToSuperGroup(req.GroupID, req.InvitedUserIDList); err != nil { if err := s.GroupInterface.AddUserToSuperGroup(ctx, req.GroupID, req.InvitedUserIDList); err != nil {
return nil, err return nil, err
} }
for _, userID := range req.InvitedUserIDList {
chat.SuperGroupNotification(tools.OperationID(ctx), userID, userID)
} }
if groupInfo.GroupType != constant.SuperGroup {
chat.MemberInvitedNotification(tools.OperationID(ctx), req.GroupID, tools.OpUserID(ctx), req.Reason, okUserIDList)
} else { } else {
var groupMembers []*relation.GroupMember
for _, userID := range req.InvitedUserIDList { for _, userID := range req.InvitedUserIDList {
if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { user := userMap[userID]
trace_log.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) var member relation.GroupMember
utils.CopyStructFields(&member, user)
member.GroupID = req.GroupID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = tools.OpUserID(ctx)
member.InviterUserID = tools.OpUserID(ctx)
member.JoinSource = constant.JoinByInvitation
if err := CallbackBeforeMemberJoinGroup(ctx, tools.OperationID(ctx), &member, group.Ex); err != nil {
return nil, err
} }
groupMembers = append(groupMembers, &member)
} }
for _, v := range req.InvitedUserIDList { if err := s.GroupInterface.CreateGroupMember(ctx, groupMembers); err != nil {
chat.SuperGroupNotification(tools.OperationID(ctx), v, v) return nil, err
} }
chat.MemberInvitedNotification(tools.OperationID(ctx), req.GroupID, tools.OpUserID(ctx), req.Reason, req.InvitedUserIDList)
} }
return resp, nil return resp, nil
} }
func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) { func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGroupAllMemberReq) (*pbGroup.GetGroupAllMemberResp, error) {
resp := &pbGroup.GetGroupAllMemberResp{} resp := &pbGroup.GetGroupAllMemberResp{}
group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if groupInfo.GroupType != constant.SuperGroup { if group.GroupType != constant.SuperGroup {
memberList, err := rocksCache.GetGroupMembersInfoFromCache(ctx, req.Count, req.Offset, req.GroupID) members, err := s.GroupInterface.GetGroupMemberList(ctx, req.GroupID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
for _, v := range memberList { var userIDs []string
for _, member := range members {
userIDs = append(userIDs, member.UserID)
}
for _, member := range members {
var node open_im_sdk.GroupMemberFullInfo var node open_im_sdk.GroupMemberFullInfo
cp.GroupMemberDBCopyOpenIM(&node, v) utils.CopyStructFields(&node, member)
resp.MemberList = append(resp.MemberList, &node) resp.MemberList = append(resp.MemberList, &node)
} }
} }

7
pkg/common/db/controller/group.go
Unescape View File

@ -18,10 +18,17 @@ type GroupInterface interface {
DeleteGroupByIDs(ctx context.Context, groupIDs []string) error DeleteGroupByIDs(ctx context.Context, groupIDs []string) error
TakeGroupByID(ctx context.Context, groupID string) (group *relation.Group, err error) TakeGroupByID(ctx context.Context, groupID string) (group *relation.Group, err error)
GetJoinedGroupList(ctx context.Context, userID string) ([]*relation.Group, error) GetJoinedGroupList(ctx context.Context, userID string) ([]*relation.Group, error)
GetGroupMemberList(ctx context.Context, groupID string) ([]*relation.GroupMember, error)
GetGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]int, error) GetGroupMemberNum(ctx context.Context, groupIDs []string) (map[string]int, error)
GetGroupOwnerUserID(ctx context.Context, groupIDs []string) (map[string]string, error) GetGroupOwnerUserID(ctx context.Context, groupIDs []string) (map[string]string, error)
CreateGroupMember(ctx context.Context, groupMember []*relation.GroupMember) error
CreateGroupRequest(ctx context.Context, requests []*relation.GroupRequest) error
//mongo //mongo
CreateSuperGroup(ctx context.Context, groupID string, initMemberIDList []string) error CreateSuperGroup(ctx context.Context, groupID string, initMemberIDList []string) error
AddUserToSuperGroup(ctx context.Context, groupID string, userIDs []string) error
GetSuperGroupByID(ctx context.Context, groupID string) (superGroup *unrelation.SuperGroup, err error) GetSuperGroupByID(ctx context.Context, groupID string) (superGroup *unrelation.SuperGroup, err error)
} }

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

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

Write Preview
Loading…
Cancel
Save