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

 Conflicts:

	internal/push/sdk/tpns-server-sdk-go/go/auth/auth.go

	pkg/proto/group/group.proto

internal/rpc/auth/auth.go

@@ -5,6 +5,7 @@ import (
 	"Open_IM/internal/common/rpc_server"
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/cache"
 	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
@@ -23,8 +24,11 @@ func NewRpcAuthServer(port int) *rpcAuth {
 	if err != nil {
 		panic(err)
 	}
+	var redis cache.RedisClient
+	redis.InitRedis()
 	return &rpcAuth{
-		RpcServer: r,
+		RpcServer:     r,
+		AuthInterface: controller.NewAuthController(redis.GetClient(), config.Config.TokenPolicy.AccessSecret, config.Config.TokenPolicy.AccessExpire),
 	}
 }
 
@@ -64,7 +68,7 @@ func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbA
 	if _, err := check.GetUsersInfo(ctx, req.UserID); err != nil {
 		return nil, err
 	}
-	token, err := s.CreateToken(ctx, req.UserID, int(req.PlatformID), config.Config.TokenPolicy.AccessExpire)
+	token, err := s.CreateToken(ctx, req.UserID, constant.PlatformIDToName(int(req.PlatformID)))
 	if err != nil {
 		return nil, err
 	}
@@ -73,39 +77,41 @@ func (s *rpcAuth) UserToken(ctx context.Context, req *pbAuth.UserTokenReq) (*pbA
 	return &resp, nil
 }
 
-func (s *rpcAuth) parseToken(ctx context.Context, tokensString, operationID string) (claims *tokenverify.Claims, err error) {
+func (s *rpcAuth) parseToken(ctx context.Context, tokensString string) (claims *tokenverify.Claims, err error) {
 	claims, err = tokenverify.GetClaimFromToken(tokensString)
 	if err != nil {
 		return nil, utils.Wrap(err, "")
 	}
-	m, err := s.GetTokens(ctx, claims.UID, claims.Platform)
+	m, err := s.GetTokensWithoutError(ctx, claims.UID, claims.Platform)
 	if err != nil {
 		return nil, err
 	}
-
+	if len(m) == 0 {
+		return nil, constant.ErrTokenNotExist.Wrap()
+	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
 		case constant.NormalToken:
 			return claims, nil
 		case constant.KickedToken:
-			return nil, utils.Wrap(constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
+			return nil, constant.ErrTokenKicked.Wrap()
 		default:
 			return nil, utils.Wrap(constant.ErrTokenUnknown, "")
 		}
 	}
-	return nil, utils.Wrap(constant.ErrTokenNotExist, "redis token map not find")
+	return nil, constant.ErrTokenNotExist.Wrap()
 }
 
-func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (*pbAuth.ParseTokenResp, error) {
-	resp := pbAuth.ParseTokenResp{}
-	claims, err := s.parseToken(ctx, req.Token, req.OperationID)
+func (s *rpcAuth) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
+	resp = &pbAuth.ParseTokenResp{}
+	claims, err := s.parseToken(ctx, req.Token)
 	if err != nil {
 		return nil, err
 	}
 	resp.UserID = claims.UID
 	resp.Platform = claims.Platform
 	resp.ExpireTimeSeconds = claims.ExpiresAt.Unix()
-	return &resp, nil
+	return resp, nil
 }
 
 func (s *rpcAuth) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq) (*pbAuth.ForceLogoutResp, error) {

internal/rpc/group/callback.go

@@ -119,7 +119,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, grou
 	return err
 }
 
-func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (err error) {
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfo) (err error) {
 	defer func() {
 		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
 	}()

internal/rpc/group/copy.go

@@ -84,7 +84,7 @@ func DbToPbGroupRequest(m *relation.GroupRequestModel, user *open_im_sdk.PublicU
 func DbToPbGroupAbstractInfo(groupID string, groupMemberNumber int32, groupMemberListHash uint64) *pbGroup.GroupAbstractInfo {
 	return &pbGroup.GroupAbstractInfo{
 		GroupID:             groupID,
-		GroupMemberNumber:   groupMemberNumber,
+		GroupMemberNumber:   uint32(groupMemberNumber),
 		GroupMemberListHash: groupMemberListHash,
 	}
 }

internal/rpc/group/db_map.go

@@ -44,7 +44,7 @@ func UpdateGroupMemberMutedTimeMap(t time.Time) map[string]any {
 	}
 }
 
-func UpdateGroupMemberMap(req *pbGroup.SetGroupMemberInfoReq) map[string]any {
+func UpdateGroupMemberMap(req *pbGroup.SetGroupMemberInfo) map[string]any {
 	m := make(map[string]any)
 	if req.Nickname != nil {
 		m["nickname"] = req.Nickname.Value

internal/rpc/group/group.go

@@ -30,7 +30,6 @@ import (
 
 	"github.com/OpenIMSDK/openKeeper"
 	"google.golang.org/grpc"
-	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
 type groupServer struct {
@@ -75,7 +74,7 @@ func NewGroupServer(port int) *groupServer {
 
 	//conns, err := g.registerCenter.GetConns(config.Config.RpcRegisterName.OpenImConversationName)
 
-	g.GroupInterface = controller.NewGroupInterface(controller.NewGroupDatabase(mysql.GormConn(), redis.GetClient(), mongo.GetClient()))
+	g.GroupInterface = controller.NewGroupInterface(mysql.GormConn(), redis.GetClient(), mongo.GetClient())
 	return &g
 }
 
@@ -191,7 +190,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 			}
 		}
 	}
-	if err := s.GroupInterface.CreateGroup(ctx, []*relation.GroupModel{group}, groupMembers); err != nil {
+	if err := s.GroupInterface.CreateGroup(ctx, []*relationTb.GroupModel{group}, groupMembers); err != nil {
 		return nil, err
 	}
 	resp.GroupInfo = DbToPbGroupInfo(group, req.OwnerUserID, uint32(len(userIDs)))
@@ -287,9 +286,9 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 				return nil, constant.ErrNoPermission.Wrap("not in group")
 			}
 			if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
-				var requests []*relation.GroupRequestModel
+				var requests []*relationTb.GroupRequestModel
 				for _, userID := range req.InvitedUserIDs {
-					requests = append(requests, &relation.GroupRequestModel{
+					requests = append(requests, &relationTb.GroupRequestModel{
 						UserID:        userID,
 						GroupID:       req.GroupID,
 						JoinSource:    constant.JoinByInvitation,
@@ -951,50 +950,79 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	return resp, nil
 }
 
-func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) {
-	_, err := s.SetGroupMemberInfo(ctx, &pbGroup.SetGroupMemberInfoReq{GroupID: req.GroupID, UserID: req.UserID, Nickname: wrapperspb.String(req.Nickname)})
-	if err != nil {
-		return nil, err
-	}
-	return &pbGroup.SetGroupMemberNicknameResp{}, nil
-}
-
 func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) {
 	resp := &pbGroup.SetGroupMemberInfoResp{}
-	if req.RoleLevel != nil && req.RoleLevel.Value == constant.GroupOwner {
-		return nil, constant.ErrNoPermission.Wrap("set group owner")
+	if len(req.Members) == 0 {
+		return nil, constant.ErrArgs.Wrap("members empty")
 	}
-	group, err := s.GroupInterface.TakeGroup(ctx, req.GroupID)
-	if err != nil {
-		return nil, err
-	}
-	if group.Status == constant.GroupStatusDismissed {
-		return nil, constant.ErrArgs.Wrap("group status is dismissed")
-	}
-	member, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, req.UserID)
-	if err != nil {
-		return nil, err
-	}
-	if tracelog.GetOpUserID(ctx) == req.UserID {
-		if req.RoleLevel != nil {
-			return nil, constant.ErrArgs.Wrap("update role level")
+	duplicateMap := make(map[[2]string]struct{})
+	userIDMap := make(map[string]struct{})
+	groupIDMap := make(map[string]struct{})
+	for _, member := range req.Members {
+		key := [...]string{member.GroupID, member.UserID}
+		if _, ok := duplicateMap[key]; ok {
+			return nil, constant.ErrArgs.Wrap("group user duplicate")
 		}
-	} else if !tokenverify.IsAppManagerUid(ctx) {
-		opMember, err := s.GroupInterface.TakeGroupMember(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
-		if err != nil {
+		duplicateMap[key] = struct{}{}
+		userIDMap[member.UserID] = struct{}{}
+		groupIDMap[member.GroupID] = struct{}{}
+	}
+	groupIDs := utils.Keys(groupIDMap)
+	userIDs := utils.Keys(userIDMap)
+	members, err := s.GroupInterface.FindGroupMember(ctx, groupIDs, append(userIDs, tracelog.GetOpUserID(ctx)), nil)
+	if err != nil {
+		return nil, err
+	}
+	for _, member := range members {
+		delete(duplicateMap, [...]string{member.GroupID, member.UserID})
+	}
+	if len(duplicateMap) > 0 {
+		return nil, constant.ErrArgs.Wrap("group not found or user not in group")
+	}
+	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) [2]string {
+		return [...]string{e.GroupID, e.UserID}
+	})
+	if !tokenverify.IsAppManagerUid(ctx) {
+		opUserID := tracelog.GetOpUserID(ctx)
+		for _, member := range members {
+			if member.UserID == opUserID {
+				continue
+			}
+			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))
+			}
+			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))
+			}
+		}
+	}
+	for _, member := range req.Members {
+		if member.RoleLevel == nil {
+			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))
+		}
+	}
+	for i := 0; i < len(req.Members); i++ {
+		if err := CallbackBeforeSetGroupMemberInfo(ctx, req.Members[i]); err != nil {
 			return nil, err
 		}
-		if opMember.RoleLevel <= member.RoleLevel {
-			return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
+	}
+	err = s.GroupInterface.UpdateGroupMembers(ctx, utils.Slice(req.Members, func(e *pbGroup.SetGroupMemberInfo) *controller.BatchUpdateGroupMember {
+		return &controller.BatchUpdateGroupMember{
+			GroupID: e.GroupID,
+			UserID:  e.UserID,
+			Map:     UpdateGroupMemberMap(e),
 		}
-	}
-	if err := CallbackBeforeSetGroupMemberInfo(ctx, req); err != nil {
+	}))
+	if err != nil {
 		return nil, err
 	}
-	if err := s.GroupInterface.UpdateGroupMember(ctx, req.GroupID, req.UserID, UpdateGroupMemberMap(req)); err != nil {
-		return nil, err
+	for _, member := range req.Members {
+		chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), member.GroupID, member.UserID)
 	}
-	chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
 	return resp, nil
 }
 
@@ -1038,3 +1066,13 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.Ge
 	})
 	return resp, nil
 }
+
+func (s *groupServer) GetGroupMemberUserID(ctx context.Context, req *pbGroup.GetGroupMemberUserIDReq) (*pbGroup.GetGroupMemberUserIDResp, error) {
+	resp := &pbGroup.GetGroupMemberUserIDResp{}
+	userIDs, err := s.GroupInterface.FindGroupMemberUserID(ctx, req.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	resp.UserIDs = userIDs
+	return resp, nil
+}