blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-06 04:15:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
withchao 2023-03-29 18:34:26 +08:00
commit c7f7e7c782
7 changed files with 118 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
cmd/api/main.go
View File

@ -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))

30
internal/rpc/group/group.go
View File

@ -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]
if !ok {
groupMembers, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{opUserID}, nil)
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
}

24
pkg/common/db/cache/group.go vendored
View File

@ -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) {

54
pkg/common/db/controller/group.go
View File

@ -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)
}

40
pkg/common/db/relation/group_member_model.go
View File

@ -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 {
GroupID string `gorm:"group_id"`
UserID string `gorm:"user_id"`
}
if err := g.db(ctx).Model(&relation.GroupMemberModel{}).Where("group_id in (?)", groupIDs).Find(&items).Error; err != nil {
var groupMembers []*relation.GroupMemberModel
if err := g.db(ctx).Select("group_id, user_id").Where("group_id in (?)", groupIDs).Find(&groupMembers).Error; err != nil {
return nil, utils.Wrap(err, "")
}
groupUsers = make(map[string][]string)
for _, item := range items {
groupUsers[item.GroupID] = append(groupUsers[item.GroupID], item.UserID)
for _, item := range groupMembers {
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
}

1
pkg/common/db/table/relation/group_member.go
View File

@ -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)
}

1
script/check_all.sh
View File

@ -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}')