IM/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2026-05-07 10:35:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Gordon
2023-02-01 15:58:14 +08:00
parent e550c9a874 4bea4252ff
commit 7c92de7899
26 changed files with 536 additions and 717 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/rpc/friend/callback.go
+14 -11
View File
@@ -6,14 +6,17 @@ import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/http"
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/tracelog"
pbFriend "Open_IM/pkg/proto/friend"
"context"
//"Open_IM/pkg/proto/msg"
"Open_IM/pkg/utils"
http2 "net/http"
)
func callbackBeforeAddFriendV1(req *pbFriend.AddFriendReq) error {
resp := callbackBeforeAddFriend(req)
func callbackBeforeAddFriendV1(ctx context.Context, req *pbFriend.AddFriendReq) error {
resp := callbackBeforeAddFriend(ctx, req)
if resp.ErrCode != 0 {
return (&constant.ErrInfo{
ErrCode: resp.ErrCode,
@@ -23,28 +26,28 @@ func callbackBeforeAddFriendV1(req *pbFriend.AddFriendReq) error {
return nil
}
func callbackBeforeAddFriend(req *pbFriend.AddFriendReq) cbApi.CommonCallbackResp {
callbackResp := cbApi.CommonCallbackResp{OperationID: req.CommID.OperationID}
func callbackBeforeAddFriend(ctx context.Context, req *pbFriend.AddFriendReq) cbApi.CommonCallbackResp {
callbackResp := cbApi.CommonCallbackResp{OperationID: tracelog.GetOperationID(ctx)}
if !config.Config.Callback.CallbackBeforeAddFriend.Enable {
return callbackResp
}
log.NewDebug(req.CommID.OperationID, utils.GetSelfFuncName(), req.String())
commonCallbackReq := &cbApi.CallbackBeforeAddFriendReq{
CallbackCommand: constant.CallbackBeforeAddFriendCommand,
FromUserID: req.CommID.FromUserID,
ToUserID: req.CommID.ToUserID,
FromUserID: req.FromUserID,
ToUserID: req.ToUserID,
ReqMsg: req.ReqMsg,
OperationID: req.CommID.OperationID,
OperationID: tracelog.GetOperationID(ctx),
}
resp := &cbApi.CallbackBeforeAddFriendResp{
CommonCallbackResp: &callbackResp,
}
//utils.CopyStructFields(req, msg.MsgData)
defer log.NewDebug(req.CommID.OperationID, utils.GetSelfFuncName(), commonCallbackReq, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeAddFriendCommand, commonCallbackReq, resp, config.Config.Callback.CallbackBeforeAddFriend.CallbackTimeOut); err != nil {
defer log.NewDebug(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), commonCallbackReq, *resp)
if err := http.CallBackPostReturn(config.Config.Callback.CallbackUrl, constant.CallbackBeforeAddFriendCommand, commonCallbackReq, resp, config.Config.Callback.CallbackBeforeAddFriend); err != nil {
callbackResp.ErrCode = http2.StatusInternalServerError
callbackResp.ErrMsg = err.Error()
if !config.Config.Callback.CallbackBeforeAddFriend.CallbackFailedContinue {
if !*config.Config.Callback.CallbackBeforeAddFriend.CallbackFailedContinue {
callbackResp.ActionCode = constant.ActionForbidden
return callbackResp
} else {
internal/rpc/friend/friend.go
+6 -6
View File
@@ -120,7 +120,7 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
if err := token_verify.CheckAccessV3(ctx, req.FromUserID); err != nil {
return nil, err
}
if err := callbackBeforeAddFriendV1(req); err != nil {
if err := callbackBeforeAddFriendV1(ctx, req); err != nil {
return nil, err
}
@@ -140,7 +140,7 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
if err = s.FriendInterface.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
return nil, err
}
chat.FriendApplicationNotification(req)
chat.FriendApplicationNotification(ctx, req)
return resp, nil
}
@@ -177,7 +177,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
if err != nil {
return nil, err
}
chat.FriendApplicationApprovedNotification(req)
chat.FriendApplicationApprovedNotification(ctx, req)
return resp, nil
}
if req.HandleResult == constant.FriendResponseRefuse {
@@ -185,7 +185,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbFriend.Res
if err != nil {
return nil, err
}
chat.FriendApplicationRejectedNotification(req)
chat.FriendApplicationRejectedNotification(ctx, req)
return resp, nil
}
return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1")
@@ -199,7 +199,7 @@ func (s *friendServer) DeleteFriend(ctx context.Context, req *pbFriend.DeleteFri
if err := s.FriendInterface.Delete(ctx, req.OwnerUserID, req.FriendUserID); err != nil {
return nil, err
}
chat.FriendDeletedNotification(req)
chat.FriendDeletedNotification(ctx, req)
return resp, nil
}
@@ -211,7 +211,7 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
if err := s.FriendInterface.UpdateRemark(ctx, req.OwnerUserID, req.FriendUserID, req.Remark); err != nil {
return nil, err
}
chat.FriendRemarkSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.OwnerUserID, req.FriendUserID)
chat.FriendRemarkSetNotification(ctx, req.OwnerUserID, req.FriendUserID)
return resp, nil
}
internal/rpc/group/g.go
+28 -30
View File
@@ -1,9 +1,7 @@
package group
import (
"Open_IM/pkg/common/constant"
relation "Open_IM/pkg/common/db/mysql"
pbGroup "Open_IM/pkg/proto/group"
"Open_IM/pkg/common/tracelog"
sdk_ws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"context"
@@ -12,32 +10,32 @@ import (
"time"
)
func getDBGroupRequest(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (dbGroupRequest *relation.GroupRequest) {
dbGroupRequest = &relation.GroupRequest{}
utils.CopyStructFields(&dbGroupRequest, req)
dbGroupRequest.UserID = req.FromUserID
dbGroupRequest.HandleUserID = utils.OpUserID(ctx)
dbGroupRequest.HandledTime = time.Now()
return dbGroupRequest
}
func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMember *relation.GroupMember, err error) {
dbGroupMember = &relation.GroupMember{}
member := relation.GroupMember{}
member.GroupID = groupID
member.UserID = userID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = utils.OpUserID(ctx)
member.FaceURL = user.FaceURL
member.Nickname = user.Nickname
member.JoinSource = request.JoinSource
member.InviterUserID = request.InviterUserID
member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
return dbGroupMember, nil
}
//func getDBGroupRequest(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (dbGroupRequest *relation.GroupRequest) {
// dbGroupRequest = &relation.GroupRequest{}
// utils.CopyStructFields(&dbGroupRequest, req)
// dbGroupRequest.UserID = req.FromUserID
// dbGroupRequest.HandleUserID = utils.OpUserID(ctx)
// dbGroupRequest.HandledTime = time.Now()
// return dbGroupRequest
//}
//
//func getDBGroupMember(ctx context.Context, groupID, userID string) (dbGroupMember *relation.GroupMember, err error) {
// dbGroupMember = &relation.GroupMember{}
//
// member := relation.GroupMember{}
// member.GroupID = groupID
// member.UserID = userID
// member.RoleLevel = constant.GroupOrdinaryUsers
// member.OperatorUserID = utils.OpUserID(ctx)
//
// member.FaceURL = user.FaceURL
// member.Nickname = user.Nickname
// member.JoinSource = request.JoinSource
// member.InviterUserID = request.InviterUserID
// member.MuteEndTime = time.Unix(int64(time.Now().Second()), 0)
//
// return dbGroupMember, nil
//}
func getUsersInfo(ctx context.Context, userIDs []string) ([]*sdk_ws.UserInfo, error) {
return nil, nil
@@ -59,7 +57,7 @@ func genGroupID(ctx context.Context, groupID string) string {
if groupID != "" {
return groupID
}
groupID = utils.Md5(utils.OperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
groupID = utils.Md5(tracelog.GetOperationID(ctx) + strconv.FormatInt(time.Now().UnixNano(), 10))
bi := big.NewInt(0)
bi.SetString(groupID[0:8], 16)
groupID = bi.String()
internal/rpc/group/group.go
+173 -189
View File
@@ -14,8 +14,8 @@ import (
promePkg "Open_IM/pkg/common/prometheus"
"Open_IM/pkg/common/token_verify"
"Open_IM/pkg/common/tracelog"
"fmt"
cp "Open_IM/internal/utils"
"Open_IM/pkg/getcdv3"
pbConversation "Open_IM/pkg/proto/conversation"
pbGroup "Open_IM/pkg/proto/group"
@@ -144,7 +144,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, constant.ErrArgs.Wrap("no group owner")
}
var userIDs []string
for _, userID := range req.InitMemberList {
for _, userID := range req.InitMembers {
userIDs = append(userIDs, userID)
}
for _, userID := range req.AdminUserIDs {
@@ -179,12 +179,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, err
}
} else {
opUserID := utils.OpUserID(ctx)
joinGroup := func(userID string, roleLevel int32) error {
user := userMap[userID]
groupMember := &relation.GroupMember{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: opUserID, JoinSource: constant.JoinByInvitation, InviterUserID: opUserID}
groupMember := &relation.GroupMember{GroupID: group.GroupID, RoleLevel: roleLevel, OperatorUserID: tracelog.GetOpUserID(ctx), JoinSource: constant.JoinByInvitation, InviterUserID: tracelog.GetOpUserID(ctx)}
utils.CopyStructFields(&groupMember, user)
if err := CallbackBeforeMemberJoinGroup(ctx, utils.OperationID(ctx), groupMember, group.Ex); err != nil {
if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), groupMember, group.Ex); err != nil {
return err
}
groupMembers = append(groupMembers, groupMember)
@@ -198,7 +197,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, err
}
}
for _, userID := range req.InitMemberList {
for _, userID := range req.InitMembers {
if err := joinGroup(userID, constant.GroupOrdinaryUsers); err != nil {
return nil, err
}
@@ -212,11 +211,11 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
if req.GroupInfo.GroupType == constant.SuperGroup {
go func() {
for _, userID := range userIDs {
chat.SuperGroupNotification(utils.OperationID(ctx), userID, userID)
chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
}
}()
} else {
chat.GroupCreatedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), group.GroupID, userIDs)
chat.GroupCreatedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), group.GroupID, userIDs)
}
return resp, nil
}
@@ -255,18 +254,18 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
groupNode.OwnerUserID = groupOwnerUserID[group.GroupID]
groupNode.CreateTime = group.CreateTime.UnixMilli()
groupNode.NotificationUpdateTime = group.NotificationUpdateTime.UnixMilli()
resp.GroupList = append(resp.GroupList, &groupNode)
resp.Groups = append(resp.Groups, &groupNode)
}
resp.Total = int32(len(resp.GroupList))
resp.Total = int32(len(resp.Groups))
return resp, nil
}
func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
resp := &pbGroup.InviteUserToGroupResp{}
if len(req.InvitedUserIDList) == 0 {
if len(req.InvitedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("user empty")
}
if utils.IsDuplicateID(req.InvitedUserIDList) {
if utils.IsDuplicateID(req.InvitedUserIDs) {
return nil, constant.ErrArgs.Wrap("userID duplicate")
}
group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
@@ -284,30 +283,30 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
for i, member := range members {
memberMap[member.GroupID] = members[i]
}
for _, userID := range req.InvitedUserIDList {
for _, userID := range req.InvitedUserIDs {
if _, ok := memberMap[userID]; ok {
return nil, constant.ErrArgs.Wrap("user in group " + userID)
}
}
userMap, err := getUserMap(ctx, req.InvitedUserIDList)
userMap, err := getUserMap(ctx, req.InvitedUserIDs)
if err != nil {
return nil, err
}
for _, userID := range req.InvitedUserIDList {
for _, userID := range req.InvitedUserIDs {
if _, ok := userMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID)
}
}
if group.NeedVerification == constant.AllNeedVerification {
if !token_verify.IsAppManagerUid(ctx) {
opUserID := utils.OpUserID(ctx)
opUserID := tracelog.GetOpUserID(ctx)
member, ok := memberMap[opUserID]
if ok {
if !ok {
return nil, constant.ErrNoPermission.Wrap("not in group")
}
if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
var requests []*relation.GroupRequest
for _, userID := range req.InvitedUserIDList {
for _, userID := range req.InvitedUserIDs {
requests = append(requests, &relation.GroupRequest{
UserID: userID,
GroupID: req.GroupID,
@@ -331,24 +330,25 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
}
}
if group.GroupType == constant.SuperGroup {
if err := s.GroupInterface.AddUserToSuperGroup(ctx, req.GroupID, req.InvitedUserIDList); err != nil {
if err := s.GroupInterface.AddUserToSuperGroup(ctx, req.GroupID, req.InvitedUserIDs); err != nil {
return nil, err
}
for _, userID := range req.InvitedUserIDList {
chat.SuperGroupNotification(utils.OperationID(ctx), userID, userID)
for _, userID := range req.InvitedUserIDs {
chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
}
} else {
opUserID := tracelog.GetOpUserID(ctx)
var groupMembers []*relation.GroupMember
for _, userID := range req.InvitedUserIDList {
for _, userID := range req.InvitedUserIDs {
user := userMap[userID]
var member relation.GroupMember
utils.CopyStructFields(&member, user)
member.GroupID = req.GroupID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = utils.OpUserID(ctx)
member.InviterUserID = utils.OpUserID(ctx)
member.OperatorUserID = opUserID
member.InviterUserID = opUserID
member.JoinSource = constant.JoinByInvitation
if err := CallbackBeforeMemberJoinGroup(ctx, utils.OperationID(ctx), &member, group.Ex); err != nil {
if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), &member, group.Ex); err != nil {
return nil, err
}
groupMembers = append(groupMembers, &member)
@@ -356,7 +356,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
if err := s.GroupInterface.CreateGroupMember(ctx, groupMembers); err != nil {
return nil, err
}
chat.MemberInvitedNotification(utils.OperationID(ctx), req.GroupID, utils.OpUserID(ctx), req.Reason, req.InvitedUserIDList)
chat.MemberInvitedNotification(tracelog.GetOperationID(ctx), req.GroupID, tracelog.GetOpUserID(ctx), req.Reason, req.InvitedUserIDs)
}
return resp, nil
}
@@ -379,7 +379,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
for _, member := range members {
var node open_im_sdk.GroupMemberFullInfo
utils.CopyStructFields(&node, member)
resp.MemberList = append(resp.MemberList, &node)
resp.Members = append(resp.Members, &node)
}
}
return resp, nil
@@ -387,20 +387,14 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbGroup.GetGroupMemberListReq) (*pbGroup.GetGroupMemberListResp, error) {
resp := &pbGroup.GetGroupMemberListResp{}
memberList, err := s.GroupInterface.GetGroupMemberFilterList(ctx, req.GroupID, req.Filter, req.NextSeq, 30)
members, err := s.GroupInterface.GetGroupMemberFilterList(ctx, req.GroupID, req.Filter, req.Pagination.PageNumber, req.Pagination.ShowNumber)
if err != nil {
return nil, err
}
for _, v := range memberList {
var node open_im_sdk.GroupMemberFullInfo
utils.CopyStructFields(&node, &v)
resp.MemberList = append(resp.MemberList, &node)
}
//db operate get db sorted by join time
if int32(len(memberList)) < 30 {
resp.NextSeq = 0
} else {
resp.NextSeq = req.NextSeq + int32(len(memberList))
for _, member := range members {
var info open_im_sdk.GroupMemberFullInfo
utils.CopyStructFields(&info, &member)
resp.Members = append(resp.Members, &info)
}
return resp, nil
}
@@ -415,132 +409,86 @@ func (s *groupServer) getGroupUserLevel(groupID, userID string) (int, error) {
if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
opFlag = 0
} else if opInfo.RoleLevel == constant.GroupOwner {
opFlag = 2 //owner
opFlag = 2 // owner
} else {
opFlag = 3 //admin
opFlag = 3 // admin
}
} else {
opFlag = 1 //app manager
opFlag = 1 // app manager
}
return opFlag, nil
}
func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGroupMemberReq) (*pbGroup.KickGroupMemberResp, error) {
resp := &pbGroup.KickGroupMemberResp{}
groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
group, err := s.GroupInterface.TakeGroupByID(ctx, req.GroupID)
if err != nil {
return nil, err
}
var okUserIDList []string
if groupInfo.GroupType != constant.SuperGroup {
opFlag := 0
if !token_verify.IsManagerUserID(utils.OpUserID(ctx)) {
opInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, utils.OpUserID(ctx))
if err != nil {
return nil, err
}
if opInfo.RoleLevel == constant.GroupOrdinaryUsers {
return nil, utils.Wrap(constant.ErrNoPermission, "")
} else if opInfo.RoleLevel == constant.GroupOwner {
opFlag = 2 //owner
} else {
opFlag = 3 //admin
}
} else {
opFlag = 1 //app manager
}
//op is group owner?
if len(req.KickedUserIDList) == 0 {
//log.NewError(req.OperationID, "failed, kick list 0")
//return &pbGroup.KickGroupMemberResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}, nil
return nil, utils.Wrap(constant.ErrArgs, "")
}
if err := s.DelGroupAndUserCache(ctx, req.GroupID, req.KickedUserIDList); err != nil {
return nil, err
}
//remove
for _, v := range req.KickedUserIDList {
kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v)
if err != nil {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
tracelog.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
continue
}
if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
continue
}
if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
continue
}
err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v)
tracelog.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
if err != nil {
log.NewError(utils.OperationID(ctx), "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
} else {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: 0})
okUserIDList = append(okUserIDList, v)
}
}
var reqPb pbUser.SetConversationReq
var c pbConversation.Conversation
for _, v := range okUserIDList {
reqPb.OperationID = utils.OperationID(ctx)
c.OwnerUserID = v
c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
c.ConversationType = constant.GroupChatType
c.GroupID = req.GroupID
c.IsNotInGroup = true
reqPb.Conversation = &c
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
if err != nil {
return nil, err
}
client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb)
tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
}
} else {
okUserIDList = req.KickedUserIDList
if err := db.DB.RemoverUserFromSuperGroup(req.GroupID, okUserIDList); err != nil {
return nil, err
}
if len(req.KickedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("KickedUserIDs empty")
}
if groupInfo.GroupType != constant.SuperGroup {
for _, userID := range okUserIDList {
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil {
tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
}
}
chat.MemberKickedNotification(req, okUserIDList)
} else {
for _, userID := range okUserIDList {
if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
}
if utils.IsDuplicateStringSlice(req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("KickedUserIDs duplicate")
}
opUserID := tracelog.GetOpUserID(ctx)
if utils.IsContain(opUserID, req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("opUserID in KickedUserIDs")
}
if group.GroupType == constant.SuperGroup {
if err := s.GroupInterface.DelSuperGroupMember(ctx, req.GroupID, req.KickedUserIDs); err != nil {
return nil, err
}
go func() {
for _, v := range req.KickedUserIDList {
chat.SuperGroupNotification(utils.OperationID(ctx), v, v)
for _, userID := range req.KickedUserIDs {
chat.SuperGroupNotification(tracelog.GetOperationID(ctx), userID, userID)
}
}()
} else {
members, err := s.GroupInterface.FindGroupMembersByID(ctx, req.GroupID, append(req.KickedUserIDs, opUserID))
if err != nil {
return nil, err
}
memberMap := make(map[string]*relation.GroupMember)
for i, member := range members {
memberMap[member.UserID] = members[i]
}
for _, userID := range req.KickedUserIDs {
if _, ok := memberMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID)
}
}
if !token_verify.IsAppManagerUid(ctx) {
member := memberMap[opUserID]
if member == nil {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
}
switch member.RoleLevel {
case constant.GroupOwner:
case constant.GroupAdmin:
for _, member := range members {
if member.UserID == opUserID {
continue
}
if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
return nil, constant.ErrNoPermission.Wrap("userID:" + member.UserID)
}
}
default:
return nil, constant.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
}
}
if err := s.GroupInterface.DelGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
return nil, err
}
chat.MemberKickedNotification(req, req.KickedUserIDs)
}
return resp, nil
}
func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
resp := &pbGroup.GetGroupMembersInfoResp{}
members, err := s.GroupInterface.GetGroupMemberListByUserID(ctx, req.GroupID, req.MemberList)
members, err := s.GroupInterface.GetGroupMemberListByUserID(ctx, req.GroupID, req.Members)
if err != nil {
return nil, err
}
@@ -548,7 +496,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetG
var memberNode open_im_sdk.GroupMemberFullInfo
utils.CopyStructFields(&memberNode, member)
memberNode.JoinTime = member.JoinTime.UnixMilli()
resp.MemberList = append(resp.MemberList, &memberNode)
resp.Members = append(resp.Members, &memberNode)
}
return resp, nil
}
@@ -578,15 +526,51 @@ func FillPublicUserInfoByUserID(operationID, userID string, userInfo *open_im_sd
func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.GetGroupApplicationListReq) (*pbGroup.GetGroupApplicationListResp, error) {
resp := &pbGroup.GetGroupApplicationListResp{}
reply, err := relation.GetRecvGroupApplicationList(req.FromUserID)
groupRequests, err := s.GroupInterface.GetGroupRecvApplicationList(ctx, req.FromUserID)
if err != nil {
return nil, err
}
if len(groupRequests) == 0 {
return resp, nil
}
var (
userIDs []string
groupIDs []string
)
for _, gr := range groupRequests {
userIDs = append(userIDs, gr.UserID)
groupIDs = append(groupIDs, gr.GroupID)
}
userMap, err := getUserMap(ctx, userIDs)
if err != nil {
return nil, err
}
for _, userID := range userIDs {
if _, ok := userMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID)
}
}
groups, err := s.GroupInterface.FindGroupsByID(ctx, groupIDs)
if err != nil {
return nil, err
}
groupMap := make(map[string]*relation.Group)
for i, group := range groups {
groupMap[group.GroupID] = groups[i]
}
for _, gr := range groupRequests {
groupRequest := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(&groupRequest, gr)
getUserMap()
}
var errResult error
tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
for _, v := range reply {
tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", groupRequests)
for _, v := range groupRequests {
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
err := FillGroupInfoByGroupID(utils.OperationID(ctx), v.GroupID, node.GroupInfo)
err := FillGroupInfoByGroupID(tracelog.GetOperationID(ctx), v.GroupID, node.GroupInfo)
if err != nil {
if !errors.Is(errors.Unwrap(err), constant.ErrDismissedAlready) {
errResult = err
@@ -594,7 +578,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
continue
}
tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
err = FillPublicUserInfoByUserID(utils.OperationID(ctx), v.UserID, node.UserInfo)
err = FillPublicUserInfoByUserID(tracelog.GetOperationID(ctx), v.UserID, node.UserInfo)
if err != nil {
errResult = err
continue
@@ -639,7 +623,7 @@ func CheckPermission(ctx context.Context, groupID string, userID string) (err er
func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
resp := &pbGroup.GroupApplicationResponseResp{}
if err := CheckPermission(ctx, req.GroupID, utils.OpUserID(ctx)); err != nil {
if err := CheckPermission(ctx, req.GroupID, tracelog.GetOpUserID(ctx)); err != nil {
return nil, err
}
groupRequest := getDBGroupRequest(ctx, req)
@@ -655,7 +639,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
if err != nil {
return nil, err
}
err = CallbackBeforeMemberJoinGroup(ctx, utils.OperationID(ctx), member, groupInfo.Ex)
err = CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), member, groupInfo.Ex)
if err != nil {
return nil, err
}
@@ -663,12 +647,12 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
if err != nil {
return nil, err
}
etcdCacheConn, err := fault_tolerant.GetDefaultConn(config.Config.RpcRegisterName.OpenImCacheName, utils.OperationID(ctx))
etcdCacheConn, err := fault_tolerant.GetDefaultConn(config.Config.RpcRegisterName.OpenImCacheName, tracelog.GetOperationID(ctx))
if err != nil {
return nil, err
}
cacheClient := pbCache.NewCacheClient(etcdCacheConn)
cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{OperationID: utils.OperationID(ctx), GroupID: req.GroupID})
cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{OperationID: tracelog.GetOperationID(ctx), GroupID: req.GroupID})
if err != nil {
return nil, err
}
@@ -695,7 +679,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
resp := &pbGroup.JoinGroupResp{}
if _, err := relation.GetUserByUserID(utils.OpUserID(ctx)); err != nil {
if _, err := relation.GetUserByUserID(tracelog.GetOpUserID(ctx)); err != nil {
return nil, err
}
groupInfo, err := rocksCache.GetGroupInfoFromCache(ctx, req.GroupID)
@@ -708,17 +692,17 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
if groupInfo.NeedVerification == constant.Directly {
if groupInfo.GroupType != constant.SuperGroup {
us, err := relation.GetUserByUserID(utils.OpUserID(ctx))
us, err := relation.GetUserByUserID(tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
//to group member
groupMember := relation.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: utils.OpUserID(ctx)}
groupMember := relation.GroupMember{GroupID: req.GroupID, RoleLevel: constant.GroupOrdinaryUsers, OperatorUserID: tracelog.GetOpUserID(ctx)}
utils.CopyStructFields(&groupMember, us)
if err := CallbackBeforeMemberJoinGroup(ctx, utils.OperationID(ctx), &groupMember, groupInfo.Ex); err != nil {
if err := CallbackBeforeMemberJoinGroup(ctx, tracelog.GetOperationID(ctx), &groupMember, groupInfo.Ex); err != nil {
return nil, err
}
if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{utils.OpUserID(ctx)}); err != nil {
if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{tracelog.GetOpUserID(ctx)}); err != nil {
return nil, err
}
err = relation.InsertIntoGroupMember(groupMember)
@@ -734,8 +718,8 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
}
var reqPb pbUser.SetConversationReq
var c pbConversation.Conversation
reqPb.OperationID = utils.OperationID(ctx)
c.OwnerUserID = utils.OpUserID(ctx)
reqPb.OperationID = tracelog.GetOperationID(ctx)
c.OwnerUserID = tracelog.GetOpUserID(ctx)
c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, sessionType)
c.ConversationType = int32(sessionType)
c.GroupID = req.GroupID
@@ -749,7 +733,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb)
tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
chat.MemberEnterDirectlyNotification(req.GroupID, utils.OpUserID(ctx), utils.OperationID(ctx))
chat.MemberEnterDirectlyNotification(req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
return resp, nil
} else {
constant.SetErrorForResp(constant.ErrGroupTypeNotSupport, resp.CommonResp)
@@ -757,7 +741,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
}
}
var groupRequest relation.GroupRequest
groupRequest.UserID = utils.OpUserID(ctx)
groupRequest.UserID = tracelog.GetOpUserID(ctx)
groupRequest.ReqMsg = req.ReqMessage
groupRequest.GroupID = req.GroupID
groupRequest.JoinSource = req.JoinSource
@@ -777,31 +761,31 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
return nil, err
}
if groupInfo.GroupType != constant.SuperGroup {
_, err = rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, utils.OpUserID(ctx))
_, err = rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{utils.OpUserID(ctx)}); err != nil {
if err := s.DelGroupAndUserCache(ctx, req.GroupID, []string{tracelog.GetOpUserID(ctx)}); err != nil {
return nil, err
}
err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, utils.OpUserID(ctx))
err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
} else {
okUserIDList := []string{utils.OpUserID(ctx)}
okUserIDList := []string{tracelog.GetOpUserID(ctx)}
if err := db.DB.RemoverUserFromSuperGroup(req.GroupID, okUserIDList); err != nil {
return nil, err
}
}
if groupInfo.GroupType != constant.SuperGroup {
_ = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, utils.OpUserID(ctx))
_ = rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
chat.MemberQuitNotification(req)
} else {
_ = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, utils.OpUserID(ctx))
_ = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, tracelog.GetOpUserID(ctx))
_ = rocksCache.DelGroupMemberListHashFromCache(ctx, req.GroupID)
chat.SuperGroupNotification(utils.OperationID(ctx), utils.OpUserID(ctx), utils.OpUserID(ctx))
chat.SuperGroupNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
}
return resp, nil
}
@@ -870,7 +854,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
var groupInfo relation.Group
utils.CopyStructFields(&groupInfo, req.GroupInfoForSet)
if req.GroupInfoForSet.Notification != "" {
groupInfo.NotificationUserID = utils.OpUserID(ctx)
groupInfo.NotificationUserID = tracelog.GetOpUserID(ctx)
groupInfo.NotificationUpdateTime = time.Now()
}
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupInfoForSet.GroupID); err != nil {
@@ -881,11 +865,11 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return nil, err
}
if changedType != 0 {
chat.GroupInfoSetNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification)
chat.GroupInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupInfoForSet.GroupID, groupName, notification, introduction, faceURL, req.GroupInfoForSet.NeedVerification)
}
if req.GroupInfoForSet.Notification != "" {
//get group member user id
getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: utils.OperationID(ctx), GroupID: req.GroupInfoForSet.GroupID}
getGroupMemberIDListFromCacheReq := &pbCache.GetGroupMemberIDListFromCacheReq{OperationID: tracelog.GetOperationID(ctx), GroupID: req.GroupInfoForSet.GroupID}
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
if err != nil {
return nil, err
@@ -900,13 +884,13 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
}
var conversationReq pbConversation.ModifyConversationFieldReq
conversation := pbConversation.Conversation{
OwnerUserID: utils.OpUserID(ctx),
OwnerUserID: tracelog.GetOpUserID(ctx),
ConversationID: utils.GetConversationIDBySessionType(req.GroupInfoForSet.GroupID, constant.GroupChatType),
ConversationType: constant.GroupChatType,
GroupID: req.GroupInfoForSet.GroupID,
}
conversationReq.Conversation = &conversation
conversationReq.OperationID = utils.OperationID(ctx)
conversationReq.OperationID = tracelog.GetOperationID(ctx)
conversationReq.FieldType = constant.FieldGroupAtType
conversation.GroupAtType = constant.GroupNotification
conversationReq.UserIDList = cacheResp.UserIDList
@@ -1019,7 +1003,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbGroup.GetGr
if err != nil {
return nil, err
}
log.NewInfo(utils.OperationID(ctx), groupMembersCount)
log.NewInfo(tracelog.GetOperationID(ctx), groupMembersCount)
resp.MemberNums = int32(groupMembersCount)
for _, groupMember := range groupMembers {
member := open_im_sdk.GroupMemberFullInfo{}
@@ -1064,7 +1048,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) {
resp := &pbGroup.DismissGroupResp{}
if !token_verify.IsManagerUserID(utils.OpUserID(ctx)) && !relation.IsGroupOwnerAdmin(req.GroupID, utils.OpUserID(ctx)) {
if !token_verify.IsManagerUserID(tracelog.GetOpUserID(ctx)) && !relation.IsGroupOwnerAdmin(req.GroupID, tracelog.GetOpUserID(ctx)) {
return nil, utils.Wrap(constant.ErrIdentity, "")
}
@@ -1092,7 +1076,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
var reqPb pbUser.SetConversationReq
var c pbConversation.Conversation
for _, v := range memberList {
reqPb.OperationID = utils.OperationID(ctx)
reqPb.OperationID = tracelog.GetOperationID(ctx)
c.OwnerUserID = v.UserID
c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
c.ConversationType = constant.GroupChatType
@@ -1121,7 +1105,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) {
resp := &pbGroup.MuteGroupMemberResp{}
opFlag, err := s.getGroupUserLevel(req.GroupID, utils.OpUserID(ctx))
opFlag, err := s.getGroupUserLevel(req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
@@ -1149,14 +1133,14 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
if err != nil {
return nil, err
}
chat.GroupMemberMutedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID, req.MutedSeconds)
chat.GroupMemberMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID, req.MutedSeconds)
return resp, nil
}
func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) {
resp := &pbGroup.CancelMuteGroupMemberResp{}
opFlag, err := s.getGroupUserLevel(req.GroupID, utils.OpUserID(ctx))
opFlag, err := s.getGroupUserLevel(req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
@@ -1184,14 +1168,14 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
if err != nil {
return nil, err
}
chat.GroupMemberCancelMutedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID)
chat.GroupMemberCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
return resp, nil
}
func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) {
resp := &pbGroup.MuteGroupResp{}
opFlag, err := s.getGroupUserLevel(req.GroupID, utils.OpUserID(ctx))
opFlag, err := s.getGroupUserLevel(req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
@@ -1224,14 +1208,14 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
return nil, err
}
chat.GroupMutedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID)
chat.GroupMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
return resp, nil
}
func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
resp := &pbGroup.CancelMuteGroupResp{}
opFlag, err := s.getGroupUserLevel(req.GroupID, utils.OpUserID(ctx))
opFlag, err := s.getGroupUserLevel(req.GroupID, tracelog.GetOpUserID(ctx))
if err != nil {
return nil, err
}
@@ -1251,7 +1235,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
// errMsg := req.OperationID + " mutedInfo.RoleLevel == constant.GroupAdmin " + req.GroupID + req.OpUserID + err.Error()
// return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}}, nil
//}
log.Debug(utils.OperationID(ctx), "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk})
log.Debug(tracelog.GetOperationID(ctx), "UpdateGroupInfoDefaultZero ", req.GroupID, map[string]interface{}{"status": constant.GroupOk})
if err := rocksCache.DelGroupInfoFromCache(ctx, req.GroupID); err != nil {
return nil, err
}
@@ -1259,13 +1243,13 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
if err != nil {
return nil, err
}
chat.GroupCancelMutedNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID)
chat.GroupCancelMutedNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID)
return resp, nil
}
func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) {
resp := &pbGroup.SetGroupMemberNicknameResp{}
if utils.OpUserID(ctx) != req.UserID && !token_verify.IsManagerUserID(utils.OpUserID(ctx)) {
if tracelog.GetOpUserID(ctx) != req.UserID && !token_verify.IsManagerUserID(tracelog.GetOpUserID(ctx)) {
return nil, utils.Wrap(constant.ErrIdentity, "")
}
cbReq := &pbGroup.SetGroupMemberInfoReq{
@@ -1297,7 +1281,7 @@ func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.S
if err := relation.UpdateGroupMemberInfo(groupMemberInfo); err != nil {
return nil, err
}
chat.GroupMemberInfoSetNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID)
chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
return resp, nil
}
@@ -1336,13 +1320,13 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
switch req.RoleLevel.Value {
case constant.GroupOrdinaryUsers:
//msg.GroupMemberRoleLevelChangeNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, constant.GroupMemberSetToOrdinaryUserNotification)
chat.GroupMemberInfoSetNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID)
chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
case constant.GroupAdmin, constant.GroupOwner:
//msg.GroupMemberRoleLevelChangeNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID, constant.GroupMemberSetToAdminNotification)
chat.GroupMemberInfoSetNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID)
chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
}
} else {
chat.GroupMemberInfoSetNotification(utils.OperationID(ctx), utils.OpUserID(ctx), req.GroupID, req.UserID)
chat.GroupMemberInfoSetNotification(tracelog.GetOperationID(ctx), tracelog.GetOpUserID(ctx), req.GroupID, req.UserID)
}
return resp, nil
}
internal/rpc/msg/friend_notification.go
+30 -30
View File
@@ -4,9 +4,8 @@ import (
"Open_IM/internal/common/check"
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
utils2 "Open_IM/pkg/common/utils"
"Open_IM/pkg/common/tracelog"
pbFriend "Open_IM/pkg/proto/friend"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
@@ -92,82 +91,83 @@ func friendNotification(operationID, fromUserID, toUserID string, contentType in
Notification(&n)
}
func FriendApplicationNotification(operationID string, req *pbFriend.AddFriendReq) {
func FriendApplicationNotification(ctx context.Context, req *pbFriend.AddFriendReq) {
FriendApplicationTips := open_im_sdk.FriendApplicationTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationTips.FromToUserID.FromUserID = req.FromUserID
FriendApplicationTips.FromToUserID.ToUserID = req.ToUserID
friendNotification(operationID, req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
friendNotification(tracelog.GetOperationID(ctx), req.FromUserID, req.ToUserID, constant.FriendApplicationNotification, &FriendApplicationTips)
}
func FriendApplicationApprovedNotification(operationID string, req *pbFriend.RespondFriendApplyReq) {
func FriendApplicationApprovedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
friendNotification(operationID, req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
}
func FriendApplicationRejectedNotification(operationID string, req *pbFriend.RespondFriendApplyReq) {
func FriendApplicationRejectedNotification(ctx context.Context, req *pbFriend.RespondFriendApplyReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
friendNotification(operationID, req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
friendNotification(tracelog.GetOperationID(ctx), req.ToUserID, req.FromUserID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
}
func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
func FriendAddedNotification(ctx context.Context, operationID, opUserID, fromUserID, toUserID string) {
friendAddedTips := open_im_sdk.FriendAddedTips{Friend: &open_im_sdk.FriendInfo{}, OpUser: &open_im_sdk.PublicUserInfo{}}
user, err := imdb.GetUserByUserID(opUserID)
user, err := check.GetUsersInfo(context.Background(), opUserID)
if err != nil {
log.NewError(operationID, "GetUserByUserID failed ", err.Error(), opUserID)
return
}
utils2.UserDBCopyOpenIMPublicUser(friendAddedTips.OpUser, user)
friend, err := imdb.GetFriendRelationshipFromFriend(fromUserID, toUserID)
if err != nil {
log.NewError(operationID, "GetFriendRelationshipFromFriend failed ", err.Error(), fromUserID, toUserID)
return
}
utils2.FriendDBCopyOpenIM(friendAddedTips.Friend, friend)
friendAddedTips.OpUser.UserID = user[0].UserID
friendAddedTips.OpUser.Ex = user[0].Ex
friendAddedTips.OpUser.Nickname = user[0].Nickname
friendAddedTips.OpUser.FaceURL = user[0].FaceURL
friend, err := check.GetFriendsInfo(ctx, fromUserID, toUserID)
if err != nil {
return
}
friendAddedTips.Friend = friend
friendNotification(operationID, fromUserID, toUserID, constant.FriendAddedNotification, &friendAddedTips)
}
func FriendDeletedNotification(operationID string, req *pbFriend.DeleteFriendReq) {
func FriendDeletedNotification(ctx context.Context, req *pbFriend.DeleteFriendReq) {
friendDeletedTips := open_im_sdk.FriendDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
friendDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
friendDeletedTips.FromToUserID.ToUserID = req.FriendUserID
friendNotification(operationID, req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.FriendUserID, constant.FriendDeletedNotification, &friendDeletedTips)
}
func FriendRemarkSetNotification(operationID, fromUserID, toUserID string) {
func FriendRemarkSetNotification(ctx context.Context, fromUserID, toUserID string) {
friendInfoChangedTips := open_im_sdk.FriendInfoChangedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
friendInfoChangedTips.FromToUserID.ToUserID = toUserID
friendNotification(operationID, fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
friendNotification(tracelog.GetOperationID(ctx), fromUserID, toUserID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
}
func BlackAddedNotification(operationID string, req *pbFriend.AddBlackReq) {
func BlackAddedNotification(ctx context.Context, req *pbFriend.AddBlackReq) {
blackAddedTips := open_im_sdk.BlackAddedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
blackAddedTips.FromToUserID.FromUserID = req.OwnerUserID
blackAddedTips.FromToUserID.ToUserID = req.BlackUserID
friendNotification(operationID, req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackAddedNotification, &blackAddedTips)
}
func BlackDeletedNotification(operationID string, req *pbFriend.RemoveBlackReq) {
func BlackDeletedNotification(ctx context.Context, req *pbFriend.RemoveBlackReq) {
blackDeletedTips := open_im_sdk.BlackDeletedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
blackDeletedTips.FromToUserID.FromUserID = req.OwnerUserID
blackDeletedTips.FromToUserID.ToUserID = req.BlackUserID
friendNotification(operationID, req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
friendNotification(tracelog.GetOperationID(ctx), req.OwnerUserID, req.BlackUserID, constant.BlackDeletedNotification, &blackDeletedTips)
}
// send to myself
func UserInfoUpdatedNotification(operationID, opUserID string, changedUserID string) {
func UserInfoUpdatedNotification(ctx context.Context, opUserID string, changedUserID string) {
selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
friendNotification(operationID, opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
friendNotification(tracelog.GetOperationID(ctx), opUserID, changedUserID, constant.UserInfoUpdatedNotification, &selfInfoUpdatedTips)
}
func FriendInfoUpdatedNotification(operationID, changedUserID string, needNotifiedUserID string, opUserID string) {
func FriendInfoUpdatedNotification(ctx context.Context, changedUserID string, needNotifiedUserID string, opUserID string) {
selfInfoUpdatedTips := open_im_sdk.UserInfoUpdatedTips{UserID: changedUserID}
friendNotification(operationID, opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
friendNotification(tracelog.GetOperationID(ctx), opUserID, needNotifiedUserID, constant.FriendInfoUpdatedNotification, &selfInfoUpdatedTips)
}