Merge remote-tracking branch 'origin/errcode' into errcode

cmd/api/main.go

@@ -4,15 +4,17 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"gopkg.in/yaml.v3"
 	"net"
 	"strconv"
 
+	"gopkg.in/yaml.v3"
+
 	"github.com/OpenIMSDK/Open-IM-Server/internal/api"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/cmd"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/openKeeper"
 
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
@@ -31,11 +33,13 @@ func run(port int) error {
 	if port == 0 {
 		port = config.Config.Api.GinPort[0]
 	}
+	var err error
 	rdb, err := cache.NewRedis()
 	if err != nil {
 		return err
 	}
-	zk, err := openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, config.Config.Zookeeper.UserName, config.Config.Zookeeper.Password)
+	var client discoveryregistry.SvcDiscoveryRegistry
+	client, err = openKeeper.NewClient(config.Config.Zookeeper.ZkAddr, config.Config.Zookeeper.Schema, 10, config.Config.Zookeeper.UserName, config.Config.Zookeeper.Password)
 	if err != nil {
 		return err
 	}
@@ -43,11 +47,11 @@ func run(port int) error {
 	if err := yaml.NewEncoder(buf).Encode(config.Config); err != nil {
 		return err
 	}
-	if err := zk.RegisterConf2Registry(constant.OpenIMCommonConfigKey, buf.Bytes()); err != nil {
+	if err := client.RegisterConf2Registry(constant.OpenIMCommonConfigKey, buf.Bytes()); err != nil {
 		return err
 	}
 	log.NewPrivateLog(constant.LogFileName)
-	router := api.NewGinRouter(zk, rdb)
+	router := api.NewGinRouter(client, rdb)
 	var address string
 	if config.Config.Api.ListenIP != "" {
 		address = net.JoinHostPort(config.Config.Api.ListenIP, strconv.Itoa(port))

internal/rpc/group/group.go

@@ -256,16 +256,6 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if group.Status == constant.GroupStatusDismissed {
 		return nil, errs.ErrDismissedAlready.Wrap()
 	}
-	members, err := s.GroupDatabase.FindGroupMember(ctx, []string{group.GroupID}, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-	memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string {
-		return e.UserID
-	})
-	if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
-		return nil, errs.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
-	}
 	userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
 	if err != nil {
 		return nil, err
@@ -273,11 +263,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	if group.NeedVerification == constant.AllNeedVerification {
 		if !tokenverify.IsAppManagerUid(ctx) {
 			opUserID := mcontext.GetOpUserID(ctx)
-			member, ok := memberMap[opUserID]
+			groupMembers, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{opUserID}, nil)
-			if !ok {
+			if err != nil {
+				return nil, err
+			}
+			if len(groupMembers) <= 0 {
 				return nil, errs.ErrNoPermission.Wrap("not in group")
 			}
-			if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
+			if !(groupMembers[0].RoleLevel == constant.GroupOwner || groupMembers[0].RoleLevel == constant.GroupAdmin) {
 				var requests []*relationTb.GroupRequestModel
 				for _, userID := range req.InvitedUserIDs {
 					requests = append(requests, &relationTb.GroupRequestModel{
@@ -560,7 +553,6 @@ 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, errs.ErrArgs.Wrap("HandleResult unknown")
 	}
@@ -604,6 +596,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			RoleLevel:      constant.GroupOrdinaryUsers,
 			JoinTime:       time.Now(),
 			JoinSource:     groupRequest.JoinSource,
+			MuteEndTime:    time.Unix(0, 0),
 			InviterUserID:  groupRequest.InviterUserID,
 			OperatorUserID: mcontext.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
@@ -623,7 +616,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			s.Notification.GroupApplicationRejectedNotification(ctx, req)
 		}
 	}
-	return resp, nil
+	return &pbGroup.GroupApplicationResponseResp{}, nil
 }
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
@@ -869,7 +862,12 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 	if err != nil {
 		return nil, err
 	}
-	total, requests, err := s.GroupDatabase.PageGroupRequestUser(ctx, req.UserID, req.Pagination.PageNumber, req.Pagination.ShowNumber)
+	var pageNumber, showNumber int32
+	if req.Pagination != nil {
+		pageNumber = req.Pagination.PageNumber
+		showNumber = req.Pagination.ShowNumber
+	}
+	total, requests, err := s.GroupDatabase.PageGroupRequestUser(ctx, req.UserID, pageNumber, showNumber)
 	if err != nil {
 		return nil, err
 	}

pkg/common/db/cache/group.go

@@ -45,12 +45,14 @@ type GroupCache interface {
 	GetGroupsMemberIDs(ctx context.Context, groupIDs []string) (groupMemberIDs map[string][]string, err error)
 
 	DelGroupMemberIDs(groupID string) GroupCache
+
+	GetJoinedGroupIDs(ctx context.Context, userID string) (joinedGroupIDs []string, err error)
 	DelJoinedGroupID(userID ...string) GroupCache
 
 	GetGroupMemberInfo(ctx context.Context, groupID, userID string) (groupMember *relationTb.GroupMemberModel, err error)
-	GetGroupMembersInfo(ctx context.Context, groupID string, userID []string, roleLevel []int32) (groupMembers []*relationTb.GroupMemberModel, err error)
+	GetGroupMembersInfo(ctx context.Context, groupID string, userID []string) (groupMembers []*relationTb.GroupMemberModel, err error)
 	GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*relationTb.GroupMemberModel, err error)
-	GetGroupMembersPage(ctx context.Context, groupID string, showNumber, pageNumber int32) (groupMembers []*relationTb.GroupMemberModel, err error)
+	GetGroupMembersPage(ctx context.Context, groupID string, userID []string, showNumber, pageNumber int32) (total uint32, groupMembers []*relationTb.GroupMemberModel, err error)
 
 	DelGroupMembersInfo(groupID string, userID ...string) GroupCache
 
@@ -294,22 +296,28 @@ func (g *GroupCacheRedis) GetGroupMemberInfo(ctx context.Context, groupID, userI
 	})
 }
 
-func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, groupID string, userIDs []string, roleLevel []int32) ([]*relationTb.GroupMemberModel, error) {
+func (g *GroupCacheRedis) GetGroupMembersInfo(ctx context.Context, groupID string, userIDs []string) ([]*relationTb.GroupMemberModel, error) {
 	var keys []string
 	for _, userID := range userIDs {
 		keys = append(keys, g.getGroupMemberInfoKey(groupID, userID))
 	}
 	return batchGetCache(ctx, g.rcClient, keys, g.expireTime, g.GetGroupMemberIndex, func(ctx context.Context) ([]*relationTb.GroupMemberModel, error) {
-		return g.groupMemberDB.Find(ctx, []string{groupID}, userIDs, roleLevel)
+		return g.groupMemberDB.Find(ctx, []string{groupID}, userIDs, nil)
 	})
 }
 
-func (g *GroupCacheRedis) GetGroupMembersPage(ctx context.Context, groupID string, showNumber, pageNumber int32) (groupMembers []*relationTb.GroupMemberModel, err error) {
+func (g *GroupCacheRedis) GetGroupMembersPage(ctx context.Context, groupID string, userIDs []string, showNumber, pageNumber int32) (total uint32, groupMembers []*relationTb.GroupMemberModel, err error) {
 	groupMemberIDs, err := g.GetGroupMemberIDs(ctx, groupID)
 	if err != nil {
-		return nil, err
+		return 0, nil, err
 	}
-	return g.GetGroupMembersInfo(ctx, groupID, utils.Paginate(groupMemberIDs, int(showNumber), int(showNumber)), nil)
+	if userIDs != nil {
+		userIDs = utils.BothExist(userIDs, groupMemberIDs)
+	} else {
+		userIDs = groupMemberIDs
+	}
+	groupMembers, err = g.GetGroupMembersInfo(ctx, groupID, utils.Paginate(userIDs, int(showNumber), int(showNumber)))
+	return uint32(len(userIDs)), groupMembers, err
 }
 
 func (g *GroupCacheRedis) GetAllGroupMembersInfo(ctx context.Context, groupID string) (groupMembers []*relationTb.GroupMemberModel, err error) {
@@ -317,7 +325,7 @@ func (g *GroupCacheRedis) GetAllGroupMembersInfo(ctx context.Context, groupID st
 	if err != nil {
 		return nil, err
 	}
-	return g.GetGroupMembersInfo(ctx, groupID, groupMemberIDs, nil)
+	return g.GetGroupMembersInfo(ctx, groupID, groupMemberIDs)
 }
 
 func (g *GroupCacheRedis) GetAllGroupMemberInfo(ctx context.Context, groupID string) ([]*relationTb.GroupMemberModel, error) {

pkg/common/db/controller/group.go

@@ -177,9 +177,16 @@ func (g *groupDatabase) TakeGroupOwner(ctx context.Context, groupID string) (*re
 	return g.groupMemberDB.TakeOwner(ctx, groupID) // todo cache group owner
 }
 
-func (g *groupDatabase) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error) {
+func (g *groupDatabase) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) (totalGroupMembers []*relationTb.GroupMemberModel, err error) {
 	if roleLevels == nil {
-		return g.cache.GetGroupMembersInfo(ctx, groupIDs[0], userIDs, nil)
+		for _, groupID := range groupIDs {
+			groupMembers, err := g.cache.GetGroupMembersInfo(ctx, groupID, userIDs)
+			if err != nil {
+				return nil, err
+			}
+			totalGroupMembers = append(totalGroupMembers, groupMembers...)
+		}
+		return totalGroupMembers, nil
 	}
 	return g.groupMemberDB.Find(ctx, groupIDs, userIDs, roleLevels)
 }
@@ -187,8 +194,25 @@ func (g *groupDatabase) FindGroupMember(ctx context.Context, groupIDs []string,
 func (g *groupDatabase) PageGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32, pageNumber, showNumber int32) (total uint32, totalGroupMembers []*relationTb.GroupMemberModel, err error) {
 	if roleLevels == nil {
 		if pageNumber == 0 || showNumber == 0 {
+			if groupIDs == nil {
+				for _, userID := range userIDs {
+					groupIDs, err := g.cache.GetJoinedGroupIDs(ctx, userID)
+					if err != nil {
+						return 0, nil, err
+					}
+					for _, groupID := range groupIDs {
+						groupMembers, err := g.cache.GetGroupMembersInfo(ctx, groupID, []string{userID})
+						if err != nil {
+							return 0, nil, err
+						}
+						totalGroupMembers = append(totalGroupMembers, groupMembers...)
+					}
+				}
+
+				return uint32(len(totalGroupMembers)), totalGroupMembers, nil
+			}
 			for _, groupID := range groupIDs {
-				groupMembers, err := g.cache.GetAllGroupMembersInfo(ctx, groupID)
+				groupMembers, err := g.cache.GetGroupMembersInfo(ctx, groupID, userIDs)
 				if err != nil {
 					return 0, nil, err
 				}
@@ -196,16 +220,34 @@ func (g *groupDatabase) PageGroupMember(ctx context.Context, groupIDs []string,
 			}
 			return uint32(len(totalGroupMembers)), totalGroupMembers, nil
 		} else {
+			if groupIDs == nil {
+				for _, userID := range userIDs {
+					groupIDs, err := g.cache.GetJoinedGroupIDs(ctx, userID)
+					if err != nil {
+						return 0, nil, err
+					}
+					groupIDs = utils.Paginate(groupIDs, int(pageNumber), int(showNumber))
+					for _, groupID := range groupIDs {
+						groupMembers, err := g.cache.GetGroupMembersInfo(ctx, groupID, []string{userID})
+						if err != nil {
+							return 0, nil, err
+						}
+						totalGroupMembers = append(totalGroupMembers, groupMembers...)
+					}
+				}
+				return uint32(len(groupIDs)), totalGroupMembers, nil
+			}
+			var totalAll uint32
 			for _, groupID := range groupIDs {
-				groupMembers, err := g.cache.GetGroupMembersPage(ctx, groupID, pageNumber, showNumber)
+				total, groupMembers, err := g.cache.GetGroupMembersPage(ctx, groupID, userIDs, pageNumber, showNumber)
 				if err != nil {
 					return 0, nil, err
 				}
+				totalAll += total
 				totalGroupMembers = append(totalGroupMembers, groupMembers...)
 			}
-			return uint32(len(totalGroupMembers)), totalGroupMembers, nil
+			return totalAll, totalGroupMembers, nil
 		}
-
 	}
 	return g.groupMemberDB.SearchMember(ctx, "", groupIDs, userIDs, roleLevels, pageNumber, showNumber)
 }

pkg/common/db/relation/group_member_model.go

@@ -84,28 +84,48 @@ func (g *GroupMemberGorm) MapGroupMemberNum(ctx context.Context, groupIDs []stri
 }
 
 func (g *GroupMemberGorm) FindJoinUserID(ctx context.Context, groupIDs []string) (groupUsers map[string][]string, err error) {
-	var items []struct {
+	var groupMembers []*relation.GroupMemberModel
-		GroupID string `gorm:"group_id"`
+	if err := g.db(ctx).Select("group_id, user_id").Where("group_id in (?)", groupIDs).Find(&groupMembers).Error; err != nil {
-		UserID  string `gorm:"user_id"`
-	}
-	if err := g.db(ctx).Model(&relation.GroupMemberModel{}).Where("group_id in (?)", groupIDs).Find(&items).Error; err != nil {
 		return nil, utils.Wrap(err, "")
 	}
 	groupUsers = make(map[string][]string)
-	for _, item := range items {
+	for _, item := range groupMembers {
-		groupUsers[item.GroupID] = append(groupUsers[item.GroupID], item.UserID)
+		v, ok := groupUsers[item.GroupID]
+		if !ok {
+			groupUsers[item.GroupID] = []string{item.UserID}
+		} else {
+			groupUsers[item.GroupID] = append(v, item.UserID)
+		}
 	}
 	return groupUsers, nil
 }
 
 func (g *GroupMemberGorm) FindMemberUserID(ctx context.Context, groupID string) (userIDs []string, err error) {
-	return userIDs, utils.Wrap(g.db(ctx).Model(&relation.GroupMemberModel{}).Where("group_id = ?", groupID).Pluck("user_id", &userIDs).Error, "")
+	return userIDs, utils.Wrap(g.db(ctx).Where("group_id = ?", groupID).Pluck("user_id", &userIDs).Error, "")
 }
 
 func (g *GroupMemberGorm) FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error) {
-	return groupIDs, utils.Wrap(g.db(ctx).Model(&relation.GroupMemberModel{}).Where("user_id = ?", userID).Pluck("group_id", &groupIDs).Error, "")
+	return groupIDs, utils.Wrap(g.db(ctx).Where("user_id = ?", userID).Pluck("group_id", &groupIDs).Error, "")
 }
 
 func (g *GroupMemberGorm) TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error) {
-	return count, utils.Wrap(g.db(ctx).Model(&relation.GroupMemberModel{}).Where("group_id = ?", groupID).Count(&count).Error, "")
+	return count, utils.Wrap(g.db(ctx).Where("group_id = ?", groupID).Count(&count).Error, "")
+}
+
+func (g *GroupMemberGorm) FindUsersJoinedGroupID(ctx context.Context, userIDs []string) (map[string][]string, error) {
+	var groupMembers []*relation.GroupMemberModel
+	err := g.db(ctx).Select("group_id, user_id").Where("user_id IN (?)", userIDs).Find(&groupMembers).Error
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string][]string)
+	for _, groupMember := range groupMembers {
+		v, ok := result[groupMember.UserID]
+		if !ok {
+			result[groupMember.UserID] = []string{groupMember.GroupID}
+		} else {
+			result[groupMember.UserID] = append(v, groupMember.GroupID)
+		}
+	}
+	return result, nil
 }

pkg/common/db/table/relation/group_member.go

@@ -43,4 +43,5 @@ type GroupMemberModelInterface interface {
 	FindJoinUserID(ctx context.Context, groupIDs []string) (groupUsers map[string][]string, err error)
 	FindUserJoinedGroupID(ctx context.Context, userID string) (groupIDs []string, err error)
 	TakeGroupMemberNum(ctx context.Context, groupID string) (count int64, err error)
+	FindUsersJoinedGroupID(ctx context.Context, userIDs []string) (map[string][]string, error)
 }

script/check_all.sh

@@ -15,6 +15,7 @@ service_port_name=(
   openImAuthPort
   openImPushPort
   openImConversationPort
+  openImThirdPort
 )
 for i in ${service_port_name[*]}; do
   list=$(cat $config_path | grep -w ${i} | awk -F '[:]' '{print $NF}')