feat: use robot to migrate code

Signed-off-by: kubbot & kubecub <3293172751ysy@gmail.com>

internal/rpc/group/cache.go

@@ -0,0 +1,26 @@
+package group
+
+import (
+	"context"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
+	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+)
+
+func (s *groupServer) GetGroupInfoCache(ctx context.Context, req *pbGroup.GetGroupInfoCacheReq) (resp *pbGroup.GetGroupInfoCacheResp, err error) {
+	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &pbGroup.GetGroupInfoCacheResp{GroupInfo: convert.Db2PbGroupInfo(group, "", 0)}
+	return resp, nil
+}
+
+func (s *groupServer) GetGroupMemberCache(ctx context.Context, req *pbGroup.GetGroupMemberCacheReq) (resp *pbGroup.GetGroupMemberCacheResp, err error) {
+	members, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.GroupMemberID)
+	if err != nil {
+		return nil, err
+	}
+	resp = &pbGroup.GetGroupMemberCacheResp{Member: convert.Db2PbGroupMember(members)}
+	return resp, nil
+}

internal/rpc/group/callback.go

@@ -1,13 +1,141 @@
 package group
 
 import (
-	pbGroup "Open_IM/pkg/proto/group"
+	"context"
+	"time"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/callbackstruct"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/wrapperspb"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )
 
-func callbackBeforeCreateGroup(req *pbGroup.CreateGroupReq) (bool, error) {
-	return true, nil
+func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (err error) {
+	if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
+		return nil
+	}
+	cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
+		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
+		OperationID:     mcontext.GetOperationID(ctx),
+		GroupInfo:       req.GroupInfo,
+	}
+	cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+		UserID:    req.OwnerUserID,
+		RoleLevel: constant.GroupOwner,
+	})
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupAdmin,
+		})
+	}
+	for _, userID := range req.AdminUserIDs {
+		cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
+			UserID:    userID,
+			RoleLevel: constant.GroupOrdinaryUsers,
+		})
+	}
+	resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeCreateGroup)
+	if err != nil {
+		if err == errs.ErrCallbackContinue {
+			return nil
+		}
+		return err
+	}
+	utils.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
+	utils.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
+	utils.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
+	utils.NotNilReplace(&req.GroupInfo.Introduction, resp.Introduction)
+	utils.NotNilReplace(&req.GroupInfo.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&req.GroupInfo.OwnerUserID, resp.OwnerUserID)
+	utils.NotNilReplace(&req.GroupInfo.Ex, resp.Ex)
+	utils.NotNilReplace(&req.GroupInfo.Status, resp.Status)
+	utils.NotNilReplace(&req.GroupInfo.CreatorUserID, resp.CreatorUserID)
+	utils.NotNilReplace(&req.GroupInfo.GroupType, resp.GroupType)
+	utils.NotNilReplace(&req.GroupInfo.NeedVerification, resp.NeedVerification)
+	utils.NotNilReplace(&req.GroupInfo.LookMemberInfo, resp.LookMemberInfo)
+	return nil
 }
 
-func callbackAfterCreateGroup(req *pbGroup.CreateGroupReq) {
-
+func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
+	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
+		return nil
+	}
+	callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
+		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
+		OperationID:     mcontext.GetOperationID(ctx),
+		GroupID:         groupMember.GroupID,
+		UserID:          groupMember.UserID,
+		Ex:              groupMember.Ex,
+		GroupEx:         groupEx,
+	}
+	resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeMemberJoinGroup)
+	if err != nil {
+		if err == errs.ErrCallbackContinue {
+			return nil
+		}
+		return err
+	}
+	if resp.MuteEndTime != nil {
+		groupMember.MuteEndTime = time.UnixMilli(*resp.MuteEndTime)
+	}
+	utils.NotNilReplace(&groupMember.FaceURL, resp.FaceURL)
+	utils.NotNilReplace(&groupMember.Ex, resp.Ex)
+	utils.NotNilReplace(&groupMember.Nickname, resp.Nickname)
+	utils.NotNilReplace(&groupMember.RoleLevel, resp.RoleLevel)
+	return nil
+}
+
+func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMemberInfo) (err error) {
+	if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {
+		return nil
+	}
+	callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
+		CallbackCommand: constant.CallbackBeforeSetGroupMemberInfoCommand,
+		OperationID:     mcontext.GetOperationID(ctx),
+		GroupID:         req.GroupID,
+		UserID:          req.UserID,
+	}
+	if req.Nickname != nil {
+		callbackReq.Nickname = &req.Nickname.Value
+	}
+	if req.FaceURL != nil {
+		callbackReq.FaceURL = &req.FaceURL.Value
+	}
+	if req.RoleLevel != nil {
+		callbackReq.RoleLevel = &req.RoleLevel.Value
+	}
+	if req.Ex != nil {
+		callbackReq.Ex = &req.Ex.Value
+	}
+	resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
+	err = http.CallBackPostReturn(ctx, config.Config.Callback.CallbackUrl, callbackReq, resp, config.Config.Callback.CallbackBeforeSetGroupMemberInfo)
+	if err != nil {
+		if err == errs.ErrCallbackContinue {
+			return nil
+		}
+		return err
+	}
+	if resp.FaceURL != nil {
+		req.FaceURL = wrapperspb.String(*resp.FaceURL)
+	}
+	if resp.Nickname != nil {
+		req.Nickname = wrapperspb.String(*resp.Nickname)
+	}
+	if resp.RoleLevel != nil {
+		req.RoleLevel = wrapperspb.Int32(*resp.RoleLevel)
+	}
+	if resp.Ex != nil {
+		req.Ex = wrapperspb.String(*resp.Ex)
+	}
+	return nil
 }

internal/rpc/group/convert.go

@@ -0,0 +1,45 @@
+package group
+
+import (
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+)
+
+func (s *groupServer) groupDB2PB(group *relation.GroupModel, ownerUserID string, memberCount uint32) *sdkws.GroupInfo {
+	return &sdkws.GroupInfo{
+		GroupID:                group.GroupID,
+		GroupName:              group.GroupName,
+		Notification:           group.Notification,
+		Introduction:           group.Introduction,
+		FaceURL:                group.FaceURL,
+		OwnerUserID:            ownerUserID,
+		CreateTime:             group.CreateTime.UnixMilli(),
+		MemberCount:            memberCount,
+		Ex:                     group.Ex,
+		Status:                 group.Status,
+		CreatorUserID:          group.CreatorUserID,
+		GroupType:              group.GroupType,
+		NeedVerification:       group.NeedVerification,
+		LookMemberInfo:         group.LookMemberInfo,
+		ApplyMemberFriend:      group.ApplyMemberFriend,
+		NotificationUpdateTime: group.NotificationUpdateTime.UnixMilli(),
+		NotificationUserID:     group.NotificationUserID,
+	}
+}
+
+func (s *groupServer) groupMemberDB2PB(member *relation.GroupMemberModel, appMangerLevel int32) *sdkws.GroupMemberFullInfo {
+	return &sdkws.GroupMemberFullInfo{
+		GroupID:        member.GroupID,
+		UserID:         member.UserID,
+		RoleLevel:      member.RoleLevel,
+		JoinTime:       member.JoinTime.UnixMilli(),
+		Nickname:       member.Nickname,
+		FaceURL:        member.FaceURL,
+		AppMangerLevel: appMangerLevel,
+		JoinSource:     member.JoinSource,
+		OperatorUserID: member.OperatorUserID,
+		Ex:             member.Ex,
+		MuteEndTime:    member.MuteEndTime.UnixMilli(),
+		InviterUserID:  member.InviterUserID,
+	}
+}

internal/rpc/group/db_map.go

@@ -0,0 +1,63 @@
+package group
+
+import (
+	"time"
+
+	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+)
+
+func UpdateGroupInfoMap(group *sdkws.GroupInfoForSet) map[string]any {
+	m := make(map[string]any)
+	if group.GroupName != "" {
+		m["name"] = group.GroupName
+	}
+	if group.Notification != "" {
+		m["Notification"] = group.Notification
+	}
+	if group.Introduction != "" {
+		m["introduction"] = group.Introduction
+	}
+	if group.FaceURL != "" {
+		m["face_url"] = group.FaceURL
+	}
+	if group.NeedVerification != nil {
+		m["need_verification"] = group.NeedVerification.Value
+	}
+	if group.LookMemberInfo != nil {
+		m["look_member_info"] = group.LookMemberInfo.Value
+	}
+	if group.ApplyMemberFriend != nil {
+		m["apply_member_friend"] = group.ApplyMemberFriend.Value
+	}
+	return m
+}
+
+func UpdateGroupStatusMap(status int) map[string]any {
+	return map[string]any{
+		"status": status,
+	}
+}
+
+func UpdateGroupMemberMutedTimeMap(t time.Time) map[string]any {
+	return map[string]any{
+		"mute_end_time": t,
+	}
+}
+
+func UpdateGroupMemberMap(req *pbGroup.SetGroupMemberInfo) map[string]any {
+	m := make(map[string]any)
+	if req.Nickname != nil {
+		m["nickname"] = req.Nickname.Value
+	}
+	if req.FaceURL != nil {
+		m["user_group_face_url"] = req.FaceURL.Value
+	}
+	if req.RoleLevel != nil {
+		m["role_level"] = req.RoleLevel.Value
+	}
+	if req.Ex != nil {
+		m["ex"] = req.Ex.Value
+	}
+	return m
+}

internal/rpc/group/fill.go

@@ -0,0 +1,111 @@
+package group
+
+import (
+	"context"
+	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+)
+
+func (s *groupServer) FindGroupMember(ctx context.Context, groupIDs []string, userIDs []string, roleLevels []int32) ([]*relationTb.GroupMemberModel, error) {
+	members, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, userIDs, roleLevels)
+	if err != nil {
+		return nil, err
+	}
+	emptyUserIDs := make(map[string]struct{})
+	for _, member := range members {
+		if member.Nickname == "" || member.FaceURL == "" {
+			emptyUserIDs[member.UserID] = struct{}{}
+		}
+	}
+	if len(emptyUserIDs) > 0 {
+		users, err := s.User.GetPublicUserInfoMap(ctx, utils.Keys(emptyUserIDs), true)
+		if err != nil {
+			return nil, err
+		}
+		for i, member := range members {
+			user, ok := users[member.UserID]
+			if !ok {
+				continue
+			}
+			if member.Nickname == "" {
+				members[i].Nickname = user.Nickname
+			}
+			if member.FaceURL == "" {
+				members[i].FaceURL = user.FaceURL
+			}
+		}
+	}
+	return members, nil
+}
+
+func (s *groupServer) TakeGroupMember(ctx context.Context, groupID string, userID string) (*relationTb.GroupMemberModel, error) {
+	member, err := s.GroupDatabase.TakeGroupMember(ctx, groupID, userID)
+	if err != nil {
+		return nil, err
+	}
+	if member.Nickname == "" || member.FaceURL == "" {
+		user, err := s.User.GetPublicUserInfo(ctx, userID)
+		if err != nil {
+			return nil, err
+		}
+		if member.Nickname == "" {
+			member.Nickname = user.Nickname
+		}
+		if member.FaceURL == "" {
+			member.FaceURL = user.FaceURL
+		}
+	}
+	return member, nil
+}
+
+func (s *groupServer) TakeGroupOwner(ctx context.Context, groupID string) (*relationTb.GroupMemberModel, error) {
+	owner, err := s.GroupDatabase.TakeGroupOwner(ctx, groupID)
+	if err != nil {
+		return nil, err
+	}
+	if owner.Nickname == "" || owner.FaceURL == "" {
+		user, err := s.User.GetUserInfo(ctx, owner.UserID)
+		if err != nil {
+			return nil, err
+		}
+		if owner.Nickname == "" {
+			owner.Nickname = user.Nickname
+		}
+		if owner.FaceURL == "" {
+			owner.FaceURL = user.FaceURL
+		}
+	}
+	return owner, nil
+}
+
+func (s *groupServer) PageGetGroupMember(ctx context.Context, groupID string, pageNumber, showNumber int32) (uint32, []*relationTb.GroupMemberModel, error) {
+	total, members, err := s.GroupDatabase.PageGetGroupMember(ctx, groupID, pageNumber, showNumber)
+	if err != nil {
+		return 0, nil, err
+	}
+	emptyUserIDs := make(map[string]struct{})
+	for _, member := range members {
+		if member.Nickname == "" || member.FaceURL == "" {
+			emptyUserIDs[member.UserID] = struct{}{}
+		}
+	}
+	if len(emptyUserIDs) > 0 {
+		users, err := s.User.GetPublicUserInfoMap(ctx, utils.Keys(emptyUserIDs), true)
+		if err != nil {
+			return 0, nil, err
+		}
+		for i, member := range members {
+			user, ok := users[member.UserID]
+			if !ok {
+				continue
+			}
+			if member.Nickname == "" {
+				members[i].Nickname = user.Nickname
+			}
+			if member.FaceURL == "" {
+				members[i].FaceURL = user.FaceURL
+			}
+		}
+	}
+	return total, members, nil
+}

internal/rpc/group/super_group.go

@@ -0,0 +1,87 @@
+package group
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/convert"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	pbGroup "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
+	sdkws "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
+)
+
+func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.GetJoinedSuperGroupListReq) (*pbGroup.GetJoinedSuperGroupListResp, error) {
+	resp := &pbGroup.GetJoinedSuperGroupListResp{}
+	groupIDs, err := s.GroupDatabase.FindJoinSuperGroup(ctx, req.UserID)
+	if err != nil {
+		return nil, err
+	}
+	if len(groupIDs) == 0 {
+		return resp, nil
+	}
+	owners, err := s.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner})
+	if err != nil {
+		return nil, err
+	}
+	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+		return e.GroupID
+	})
+	if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
+		return nil, errs.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
+	}
+	groups, err := s.GroupDatabase.FindGroup(ctx, groupIDs)
+	if err != nil {
+		return nil, err
+	}
+	groupMap := utils.SliceToMap(groups, func(e *relation.GroupModel) string {
+		return e.GroupID
+	})
+	if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 {
+		return nil, errs.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
+	}
+	superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, groupIDs)
+	if err != nil {
+		return nil, err
+	}
+	superGroupMemberMap := utils.SliceToMapAny(superGroupMembers, func(e *unrelation.SuperGroupModel) (string, []string) {
+		return e.GroupID, e.MemberIDs
+	})
+	resp.Groups = utils.Slice(groupIDs, func(groupID string) *sdkws.GroupInfo {
+		return convert.Db2PbGroupInfo(groupMap[groupID], ownerMap[groupID].UserID, uint32(len(superGroupMemberMap)))
+	})
+	return resp, nil
+}
+
+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, errs.ErrArgs.Wrap("groupIDs empty")
+	}
+	groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
+	if err != nil {
+		return nil, err
+	}
+	superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, req.GroupIDs)
+	if err != nil {
+		return nil, err
+	}
+	superGroupMemberMap := utils.SliceToMapAny(superGroupMembers, func(e *unrelation.SuperGroupModel) (string, []string) {
+		return e.GroupID, e.MemberIDs
+	})
+	owners, err := s.FindGroupMember(ctx, req.GroupIDs, nil, []int32{constant.GroupOwner})
+	if err != nil {
+		return nil, err
+	}
+	ownerMap := utils.SliceToMap(owners, func(e *relation.GroupMemberModel) string {
+		return e.GroupID
+	})
+	resp.GroupInfos = utils.Slice(groups, func(e *relation.GroupModel) *sdkws.GroupInfo {
+		return convert.Db2PbGroupInfo(e, ownerMap[e.GroupID].UserID, uint32(len(superGroupMemberMap[e.GroupID])))
+	})
+	return resp, nil
+}