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

Refactor code

Browse Source
This commit is contained in:
wenxu12345 2022-01-16 16:31:28 +08:00
parent 87f14be30c
commit a583a31220
7 changed files with 1039 additions and 898 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
internal/rpc/friend/firend.go
View File

@ -68,48 +68,6 @@ func (s *friendServer) Run() {
}
}
////
//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
// return nil, nil
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
//// var (
//// isInBlackList int32
//// // isFriend int32
//// comment string
//// )
////
//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// // isFriend = constant.FriendFlag
//// }
//// comment = friendShip.Remark
////
//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// }
////
//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err == nil {
//// isInBlackList = constant.BlackListFlag
//// }
////
//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",}
////
//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
//// resp.Data.IsBlack = isInBlackList
//// resp.Data.OwnerUserID = req.CommID.FromUserID
//// resp.Data.Remark = comment
//// resp.Data.CreateTime = friendUserInfo.CreateTime
////
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
//// return &resp, nil
////
//}
func (s *friendServer) AddBlacklist(ctx context.Context, req *pbFriend.AddBlacklistReq) (*pbFriend.AddBlacklistResp, error) {
log.NewInfo(req.CommID.OperationID, "AddBlacklist args ", req.String())
ok := token_verify.CheckAccess(req.CommID.OpUserID, req.CommID.FromUserID)
@ -153,7 +111,7 @@ func (s *friendServer) AddFriend(ctx context.Context, req *pbFriend.AddFriendReq
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
chat.FriendApplicationAddedNotification(req)
chat.FriendApplicationNotification(req)
return &pbFriend.AddFriendResp{CommonResp: &pbFriend.CommonResp{}}, nil
}
@ -235,7 +193,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
log.NewError(req.CommID.OperationID, "GetFriendApplicationByBothUserID failed ", err.Error(), req.CommID.ToUserID, req.CommID.FromUserID)
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
friendRequest.HandleResult = req.Flag
friendRequest.HandleResult = req.HandleResult
friendRequest.HandleTime = time.Now()
//friendRequest.HandleTime.Unix()
friendRequest.HandleMsg = req.HandleMsg
@ -247,7 +205,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
}
//Change the status of the friend request form
if req.Flag == constant.FriendFlag {
if req.HandleResult == constant.FriendFlag {
//Establish friendship after find friend relationship not exists
_, err := imdb.GetFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
if err == nil {
@ -275,8 +233,13 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
chat.FriendAddedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
}
}
chat.FriendApplicationProcessedNotification(req)
if req.HandleResult == constant.FriendResponseAgree {
chat.FriendApplicationApprovedNotification(req)
} else if req.HandleResult == constant.FriendResponseRefuse {
chat.FriendApplicationRejectedNotification(req)
} else {
log.Error(req.CommID.OperationID, "HandleResult failed ", req.HandleResult)
}
log.NewInfo(req.CommID.OperationID, "rpc AddFriendResponse ok")
return &pbFriend.AddFriendResponseResp{CommonResp: &pbFriend.CommonResp{}}, nil
}
@ -345,7 +308,7 @@ func (s *friendServer) SetFriendRemark(ctx context.Context, req *pbFriend.SetFri
return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
log.NewInfo(req.CommID.OperationID, "rpc SetFriendComment ok")
chat.FriendInfoChangedNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
chat.FriendRemarkSetNotification(req.CommID.OperationID, req.CommID.OpUserID, req.CommID.FromUserID, req.CommID.ToUserID)
return &pbFriend.SetFriendRemarkResp{CommonResp: &pbFriend.CommonResp{}}, nil
}
@ -507,3 +470,45 @@ func (s *friendServer) GetSelfApplyList(ctx context.Context, req *pbFriend.GetSe
log.NewInfo(req.CommID.OperationID, "rpc GetSelfApplyList ok", pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList})
return &pbFriend.GetSelfApplyListResp{FriendRequestList: selfApplyOtherUserList}, nil
}
////
//func (s *friendServer) GetFriendsInfo(ctx context.Context, req *pbFriend.GetFriendsInfoReq) (*pbFriend.GetFriendInfoResp, error) {
// return nil, nil
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo args ", req.String())
//// var (
//// isInBlackList int32
//// // isFriend int32
//// comment string
//// )
////
//// friendShip, err := imdb.FindFriendRelationshipFromFriend(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindFriendRelationshipFromFriend failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// // isFriend = constant.FriendFlag
//// }
//// comment = friendShip.Remark
////
//// friendUserInfo, err := imdb.FindUserByUID(req.CommID.ToUserID)
//// if err != nil {
//// log.NewError(req.CommID.OperationID, "FindUserByUID failed ", err.Error())
//// return &pbFriend.GetFriendInfoResp{ErrCode: constant.ErrSearchUserInfo.ErrCode, ErrMsg: constant.ErrSearchUserInfo.ErrMsg}, nil
//// }
////
//// err = imdb.FindRelationshipFromBlackList(req.CommID.FromUserID, req.CommID.ToUserID)
//// if err == nil {
//// isInBlackList = constant.BlackListFlag
//// }
////
//// resp := pbFriend.GetFriendInfoResp{ErrCode: 0, ErrMsg: "",}
////
//// utils.CopyStructFields(resp.FriendInfoList, friendUserInfo)
//// resp.Data.IsBlack = isInBlackList
//// resp.Data.OwnerUserID = req.CommID.FromUserID
//// resp.Data.Remark = comment
//// resp.Data.CreateTime = friendUserInfo.CreateTime
////
//// log.NewInfo(req.CommID.OperationID, "GetFriendsInfo ok ", resp)
//// return &resp, nil
////
//}

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

@ -141,7 +141,6 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
resp.ErrMsg = constant.ErrDB.ErrMsg
return resp, nil
}
chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
utils.CopyStructFields(resp.GroupInfo, group)
resp.GroupInfo.MemberCount, err = imdb.GetGroupMemberNumByGroupID(groupId)
if err != nil {
@ -153,6 +152,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
resp.GroupInfo.OwnerUserID = req.OwnerUserID
log.NewInfo(req.OperationID, "rpc CreateGroup return ", resp.String())
chat.GroupCreatedNotification(req.OperationID, req.OpUserID, groupId, okUserIDList)
return resp, nil
}
@ -420,7 +420,7 @@ func (s *groupServer) GetGroupApplicationList(_ context.Context, req *pbGroup.Ge
}
cp.GroupRequestDBCopyOpenIM(&node, &v)
cp.UserDBCopyOpenIMPublic(node.UserInfo, user)
cp.UserDBCopyOpenIMPublicUser(node.UserInfo, user)
cp.GroupDBCopyOpenIM(node.GroupInfo, group)
log.NewDebug(req.OperationID, "node ", node, "v ", v)
resp.GroupRequestList = append(resp.GroupRequestList, &node)
@ -466,30 +466,33 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), groupRequest)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
chat.ApplicationProcessedNotification(req)
if req.HandleResult == constant.GroupResponseAgree {
if req.HandleResult == constant.GroupResponseAgree {
user, err := imdb.GetUserByUserID(req.FromUserID)
if err != nil {
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.FromUserID)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
member := db.GroupMember{}
member.GroupID = req.GroupID
member.UserID = req.FromUserID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = req.OpUserID
member.FaceUrl = user.FaceUrl
member.Nickname = user.Nickname
err = imdb.InsertIntoGroupMember(member)
if err != nil {
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
user, err := imdb.GetUserByUserID(req.FromUserID)
if err != nil {
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), req.FromUserID)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
member := db.GroupMember{}
member.GroupID = req.GroupID
member.UserID = req.FromUserID
member.RoleLevel = constant.GroupOrdinaryUsers
member.OperatorUserID = req.OpUserID
member.FaceUrl = user.FaceURL
member.Nickname = user.Nickname
err = imdb.InsertIntoGroupMember(member)
if err != nil {
log.NewError(req.OperationID, "GroupApplicationResponse failed ", err.Error(), member)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
chat.GroupApplicationAcceptedNotification(req)
chat.MemberEnterNotification(req)
} else if req.HandleResult == constant.GroupResponseRefuse {
chat.GroupApplicationRejectedNotification(req)
} else {
log.Error(req.OperationID, "HandleResult failed ", req.HandleResult)
return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
}
log.NewInfo(req.OperationID, "rpc GroupApplicationResponse return ", pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{}})
@ -521,7 +524,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
}
chat.JoinApplicationNotification(req)
chat.JoinGroupApplicationNotification(req)
log.NewInfo(req.OperationID, "ReceiveJoinApplicationNotification rpc return ")
return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
@ -547,7 +550,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
// return &pbGroup.CommonResp{ErrorCode: constant.ErrQuitGroup.ErrCode, ErrorMsg: constant.ErrQuitGroup.ErrMsg}, nil
}
chat.MemberLeaveNotification(req)
chat.MemberQuitNotification(req)
log.NewInfo(req.OperationID, "rpc QuitGroup return ", pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}})
return &pbGroup.QuitGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
}
@ -603,11 +606,10 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo)
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
if changedType != 0 {
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID, changedType)
}
log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}})
if changedType != 0 {
chat.GroupInfoSetNotification(req.OperationID, req.OpUserID, req.GroupInfo.GroupID)
}
return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}, nil
}
@ -630,8 +632,7 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo)
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
}
changedType := int32(1) << 4
chat.GroupInfoChangedNotification(req.OperationID, req.OpUserID, req.GroupID, changedType)
chat.GroupOwnerTransferredNotification(req)
return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil

83
internal/rpc/msg/friend_notification.go
View File

@ -58,7 +58,7 @@ func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Mess
}
cn := config.Config.Notification
switch contentType {
case constant.FriendApplicationAddedNotification:
case constant.FriendApplicationNotification:
tips.DefaultTips = fromUserNickname + cn.FriendApplicationAdded.DefaultTips.Tips
case constant.FriendApplicationApprovedNotification:
@ -69,7 +69,7 @@ func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Mess
tips.DefaultTips = cn.FriendAdded.DefaultTips.Tips
case constant.FriendDeletedNotification:
tips.DefaultTips = cn.FriendDeleted.DefaultTips.Tips + toUserNickname
case constant.FriendInfoChangedNotification:
case constant.FriendRemarkSetNotification:
tips.DefaultTips = fromUserNickname + cn.FriendInfoChanged.DefaultTips.Tips
case constant.BlackAddedNotification:
tips.DefaultTips = cn.BlackAdded.DefaultTips.Tips + toUserNickname
@ -95,12 +95,12 @@ func friendNotification(commID *pbFriend.CommID, contentType int32, m proto.Mess
Notification(&n)
}
func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) {
func FriendApplicationNotification(req *pbFriend.AddFriendReq) {
log.Info(req.CommID.OperationID, utils.GetSelfFuncName(), "args: ", req.String())
var friendApplicationAddedTips open_im_sdk.FriendApplicationAddedTips
friendApplicationAddedTips.FromToUserID.FromUserID = req.CommID.FromUserID
friendApplicationAddedTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendNotification(req.CommID, constant.FriendApplicationAddedNotification, &friendApplicationAddedTips)
friendNotification(req.CommID, constant.FriendApplicationNotification, &friendApplicationAddedTips)
//fromUserNickname, toUserNickname, err := getFromToUserNickname(req.CommID.FromUserID, req.CommID.ToUserID)
//if err != nil {
// log.Error(req.CommID.OperationID, "getFromToUserNickname failed ", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
@ -129,23 +129,18 @@ func FriendApplicationAddedNotification(req *pbFriend.AddFriendReq) {
//Notification(&n)
}
func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq) {
var friendApplicationProcessedTips open_im_sdk.FriendApplicationProcessedTips
friendApplicationProcessedTips.FromToUserID.FromUserID = req.CommID.FromUserID
friendApplicationProcessedTips.FromToUserID.ToUserID = req.CommID.ToUserID
friendApplicationProcessedTips.HandleResult = req.HandleResult
func FriendApplicationApprovedNotification(req *pbFriend.AddFriendResponseReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
//fromUserNickname, toUserNickname, err := getFromToUserNickname(req.CommID.FromUserID, req.CommID.ToUserID)
//if err != nil {
// log.Error(req.CommID.OperationID, "getFromToUserNickname failed ", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
// return
//}
if friendApplicationProcessedTips.HandleResult == 1 {
friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &friendApplicationProcessedTips)
} else if friendApplicationProcessedTips.HandleResult == -1 {
friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &friendApplicationProcessedTips)
} else {
log.Error(req.CommID.OperationID, "HandleResult failed ", friendApplicationProcessedTips.HandleResult)
}
friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &FriendApplicationApprovedTips)
//var tips open_im_sdk.TipsComm
//tips.DefaultTips = fromUserNickname + " FriendApplicationProcessedNotification " + toUserNickname
@ -170,6 +165,58 @@ func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq)
//Notification(&n)
}
func FriendApplicationRejectedNotification(req *pbFriend.AddFriendResponseReq) {
FriendApplicationApprovedTips := open_im_sdk.FriendApplicationApprovedTips{FromToUserID: &open_im_sdk.FromToUserID{}}
FriendApplicationApprovedTips.FromToUserID.FromUserID = req.CommID.FromUserID
FriendApplicationApprovedTips.FromToUserID.ToUserID = req.CommID.ToUserID
FriendApplicationApprovedTips.HandleMsg = req.HandleMsg
friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &FriendApplicationApprovedTips)
}
//
//
//func FriendApplicationProcessedNotification(req *pbFriend.AddFriendResponseReq) {
// var friendApplicationProcessedTips open_im_sdk.FriendApplicationProcessedTips
// friendApplicationProcessedTips.FromToUserID.FromUserID = req.CommID.FromUserID
// friendApplicationProcessedTips.FromToUserID.ToUserID = req.CommID.ToUserID
// friendApplicationProcessedTips.HandleResult = req.HandleResult
// //fromUserNickname, toUserNickname, err := getFromToUserNickname(req.CommID.FromUserID, req.CommID.ToUserID)
// //if err != nil {
// // log.Error(req.CommID.OperationID, "getFromToUserNickname failed ", err.Error(), req.CommID.FromUserID, req.CommID.ToUserID)
// // return
// //}
// if friendApplicationProcessedTips.HandleResult == 1 {
// friendNotification(req.CommID, constant.FriendApplicationApprovedNotification, &friendApplicationProcessedTips)
// } else if friendApplicationProcessedTips.HandleResult == -1 {
// friendNotification(req.CommID, constant.FriendApplicationRejectedNotification, &friendApplicationProcessedTips)
// } else {
// log.Error(req.CommID.OperationID, "HandleResult failed ", friendApplicationProcessedTips.HandleResult)
// }
//
// //var tips open_im_sdk.TipsComm
// //tips.DefaultTips = fromUserNickname + " FriendApplicationProcessedNotification " + toUserNickname
// //tips.Detail, err = proto.Marshal(&friendApplicationProcessedTips)
// //if err != nil {
// // log.Error(req.CommID.OperationID, "Marshal failed ", err.Error(), friendApplicationProcessedTips.String())
// // return
// //}
// //
// //var n NotificationMsg
// //n.SendID = req.CommID.FromUserID
// //n.RecvID = req.CommID.ToUserID
// //n.ContentType = constant.FriendApplicationProcessedNotification
// //n.SessionType = constant.SingleChatType
// //n.MsgFrom = constant.SysMsgType
// //n.OperationID = req.CommID.OperationID
// //n.Content, err = proto.Marshal(&tips)
// //if err != nil {
// // log.Error(req.CommID.OperationID, "Marshal failed ", err.Error(), tips.String())
// // return
// //}
// //Notification(&n)
//}
func FriendAddedNotification(operationID, opUserID, fromUserID, toUserID string) {
var friendAddedTips open_im_sdk.FriendAddedTips
user, err := imdb.GetUserByUserID(opUserID)
@ -255,7 +302,7 @@ func FriendDeletedNotification(req *pbFriend.DeleteFriendReq) {
// PublicUserInfo OpUser = 2;
// uint64 OperationTime = 3;
//}
func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID string) {
func FriendRemarkSetNotification(operationID, opUserID, fromUserID, toUserID string) {
var friendInfoChangedTips open_im_sdk.FriendInfoChangedTips
friendInfoChangedTips.FromToUserID.FromUserID = fromUserID
friendInfoChangedTips.FromToUserID.ToUserID = toUserID
@ -265,7 +312,7 @@ func FriendInfoChangedNotification(operationID, opUserID, fromUserID, toUserID s
// return
//}
commID := pbFriend.CommID{FromUserID: fromUserID, ToUserID: toUserID, OpUserID: opUserID, OperationID: operationID}
friendNotification(&commID, constant.FriendInfoChangedNotification, &friendInfoChangedTips)
friendNotification(&commID, constant.FriendRemarkSetNotification, &friendInfoChangedTips)
//var tips open_im_sdk.TipsComm
//tips.DefaultTips = fromUserNickname + " FriendDeletedNotification " + toUserNickname
//tips.Detail, err = proto.Marshal(&friendInfoChangedTips)

380
internal/rpc/msg/group_notification.go
View File

@ -10,7 +10,7 @@ import (
pbGroup "Open_IM/pkg/proto/group"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"encoding/json"
"github.com/golang/protobuf/proto"
)
//message GroupCreatedTips{
@ -63,46 +63,114 @@ func setGroupMemberInfo(groupID, userID string, groupMemberInfo *open_im_sdk.Gro
return nil
}
//func setGroupPublicUserInfo(operationID, groupID, userID string, publicUserInfo *open_im_sdk.PublicUserInfo) {
// group, err := imdb.GetGroupMemberInfoByGroupIDAndUserID(groupID, userID)
// if err != nil {
// log.NewError(operationID, "FindGroupMemberInfoByGroupIdAndUserId failed ", err.Error(), groupID, userID)
// return
// }
// utils.CopyStructFields(publicUserInfo, group)
//}
func setGroupOwnerInfo(groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(groupID)
if err != nil {
return utils.Wrap(err, "")
}
if err = utils2.GroupMemberDBCopyOpenIM(groupMemberInfo, groupMember); err != nil {
return utils.Wrap(err, "")
}
return nil
}
func setPublicUserInfo(userID string, publicUserInfo *open_im_sdk.PublicUserInfo) error {
user, err := imdb.GetUserByUserID(userID)
if err != nil {
return utils.Wrap(err, "")
}
utils2.UserDBCopyOpenIMPublicUser(publicUserInfo, user)
return nil
}
func groupNotification(contentType int32, m proto.Message, sendID, groupID, recvUserID, operationID string) {
log.Info(operationID, utils.GetSelfFuncName(), "args: ", contentType)
var err error
var tips open_im_sdk.TipsComm
tips.Detail, err = proto.Marshal(m)
if err != nil {
log.Error(operationID, "Marshal failed ", err.Error(), m.String())
return
}
cn := config.Config.Notification
switch contentType {
case constant.GroupCreatedNotification:
tips.DefaultTips = cn.GroupCreated.DefaultTips.Tips
case constant.GroupInfoSetNotification:
case constant.JoinGroupApplicationNotification:
case constant.MemberQuitNotification:
case constant.GroupApplicationAcceptedNotification:
case constant.GroupApplicationRejectedNotification:
case constant.GroupOwnerTransferredNotification:
case constant.MemberKickedNotification:
case constant.MemberInvitedNotification:
default:
log.Error(operationID, "contentType failed ", contentType)
return
}
var n NotificationMsg
n.SendID = sendID
if groupID != "" {
n.RecvID = groupID
n.SessionType = constant.GroupChatType
} else {
n.RecvID = recvUserID
n.SessionType = constant.SingleChatType
}
n.ContentType = contentType
n.OperationID = operationID
n.Content, err = proto.Marshal(&tips)
if err != nil {
log.Error(operationID, "Marshal failed ", err.Error(), tips.String())
return
}
Notification(&n)
}
//创建群后调用
func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberList []string) {
GroupCreatedTips := open_im_sdk.GroupCreatedTips{Group: &open_im_sdk.GroupInfo{},
Creator: &open_im_sdk.GroupMemberFullInfo{}}
if err := setOpUserInfo(GroupCreatedTips.Creator.UserID, groupID, GroupCreatedTips.Creator); err != nil {
log.NewError(operationID, "setOpUserInfo failed ", err.Error(), GroupCreatedTips.Creator.UserID, groupID, GroupCreatedTips.Creator)
OpUser: &open_im_sdk.GroupMemberFullInfo{}, GroupOwnerUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setOpUserInfo(opUserID, groupID, GroupCreatedTips.OpUser); err != nil {
log.NewError(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupCreatedTips.OpUser)
return
}
err := setGroupInfo(groupID, GroupCreatedTips.Group)
if err != nil {
log.NewError(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
log.Error(operationID, "setGroupInfo failed ", groupID, GroupCreatedTips.Group)
return
}
imdb.GetGroupOwnerInfoByGroupID(groupID)
if err := setGroupOwnerInfo(groupID, GroupCreatedTips.GroupOwnerUser); err != nil {
log.Error(operationID, "setGroupOwnerInfo failed", err.Error(), groupID)
return
}
for _, v := range initMemberList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
setGroupMemberInfo(groupID, v, &groupMemberInfo)
if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, v)
continue
}
GroupCreatedTips.MemberList = append(GroupCreatedTips.MemberList, &groupMemberInfo)
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(GroupCreatedTips)
tips.DefaultTips = config.Config.Notification.GroupCreated.DefaultTips.Tips
var n NotificationMsg
n.SendID = opUserID
n.RecvID = groupID
n.ContentType = constant.GroupCreatedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
n.Content, _ = json.Marshal(tips)
log.NewInfo(operationID, "Notification ", n)
Notification(&n)
groupNotification(constant.GroupCreatedNotification, &GroupCreatedTips, opUserID, groupID, "", operationID)
}
//群信息改变后掉用
func GroupInfoSetNotification(operationID, opUserID, groupID string) {
GroupInfoChangedTips := open_im_sdk.GroupInfoSetTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
return
}
if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
return
}
groupNotification(constant.GroupInfoSetNotification, &GroupInfoChangedTips, opUserID, groupID, "", operationID)
}
//message ReceiveJoinApplicationTips{
@ -114,44 +182,46 @@ func GroupCreatedNotification(operationID, opUserID, groupID string, initMemberL
// OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"`
// OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"`
//申请进群后调用
func JoinApplicationNotification(req *pbGroup.JoinGroupReq) {
func JoinGroupApplicationNotification(req *pbGroup.JoinGroupReq) {
JoinGroupApplicationTips := open_im_sdk.JoinGroupApplicationTips{Group: &open_im_sdk.GroupInfo{}, Applicant: &open_im_sdk.PublicUserInfo{}}
err := setGroupInfo(req.GroupID, JoinGroupApplicationTips.Group)
if err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, JoinGroupApplicationTips.Group)
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
apply, err := imdb.GetUserByUserID(req.OpUserID)
if err != nil {
log.NewError(req.OperationID, "FindUserByUID failed ", err.Error(), req.OpUserID)
if err = setPublicUserInfo(req.OpUserID, JoinGroupApplicationTips.Applicant); err != nil {
log.Error(req.OperationID, "setPublicUserInfo failed ", err.Error(), req.OpUserID)
return
}
utils.CopyStructFields(JoinGroupApplicationTips.Applicant, apply)
JoinGroupApplicationTips.Reason = req.ReqMessage
JoinGroupApplicationTips.ReqMsg = req.ReqMessage
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(JoinGroupApplicationTips)
tips.DefaultTips = "JoinGroupApplicationTips"
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.JoinApplicationNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.Content, _ = json.Marshal(tips)
managerList, err := imdb.GetOwnerManagerByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, "GetOwnerManagerByGroupId failed ", err.Error(), req.GroupID)
return
}
for _, v := range managerList {
n.RecvID = v.UserID
log.NewInfo(req.OperationID, "Notification ", n)
Notification(&n)
groupNotification(constant.JoinGroupApplicationNotification, &JoinGroupApplicationTips, req.OpUserID, "", v.UserID, req.OperationID)
log.NewInfo(req.OperationID, "Notification ", v)
}
}
func MemberQuitNotification(req *pbGroup.QuitGroupReq) {
MemberQuitTips := open_im_sdk.MemberQuitTips{Group: &open_im_sdk.GroupInfo{}, QuitUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberQuitTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberQuitTips.QuitUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID)
return
}
groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, req.GroupID, "", req.OperationID)
groupNotification(constant.MemberQuitNotification, &MemberQuitTips, req.OpUserID, "", req.OpUserID, req.OperationID)
}
//message ApplicationProcessedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
@ -159,70 +229,47 @@ func JoinApplicationNotification(req *pbGroup.JoinGroupReq) {
// string Reason = 4;
//}
//处理进群请求后调用
func ApplicationProcessedNotification(req *pbGroup.GroupApplicationResponseReq) {
ApplicationProcessedTips := open_im_sdk.ApplicationProcessedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, ApplicationProcessedTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, ApplicationProcessedTips.Group)
func GroupApplicationAcceptedNotification(req *pbGroup.GroupApplicationResponseReq) {
GroupApplicationAcceptedTips := open_im_sdk.GroupApplicationAcceptedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
if err := setGroupInfo(req.GroupID, GroupApplicationAcceptedTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationAcceptedTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, ApplicationProcessedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, ApplicationProcessedTips.OpUser)
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationAcceptedTips.OpUser)
return
}
ApplicationProcessedTips.Reason = req.HandledMsg
ApplicationProcessedTips.Result = req.HandleResult
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(ApplicationProcessedTips)
tips.DefaultTips = "ApplicationProcessedNotification"
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.ApplicationProcessedNotification
n.SessionType = constant.SingleChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.RecvID = req.FromUserID
n.Content, _ = json.Marshal(tips)
Notification(&n)
groupNotification(constant.GroupApplicationAcceptedNotification, &GroupApplicationAcceptedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
}
//message MemberInvitedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo InvitedUser = 3;
// uint64 OperationTime = 4;
//}
//被邀请进群后调用
func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
ApplicationProcessedTips := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, ApplicationProcessedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, ApplicationProcessedTips.Group)
func GroupApplicationRejectedNotification(req *pbGroup.GroupApplicationResponseReq) {
GroupApplicationRejectedTips := open_im_sdk.GroupApplicationRejectedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, HandleMsg: req.HandledMsg}
if err := setGroupInfo(req.GroupID, GroupApplicationRejectedTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, GroupApplicationRejectedTips.Group)
return
}
if err := setOpUserInfo(opUserID, groupID, ApplicationProcessedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, ApplicationProcessedTips.OpUser)
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID, GroupApplicationRejectedTips.OpUser)
return
}
for _, v := range invitedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
log.Error(operationID, "setGroupMemberInfo faield ", err.Error(), groupID)
continue
}
ApplicationProcessedTips.InvitedUserList = append(ApplicationProcessedTips.InvitedUserList, &groupMemberInfo)
groupNotification(constant.GroupApplicationRejectedNotification, &GroupApplicationRejectedTips, req.OpUserID, "", req.FromUserID, req.OperationID)
}
func GroupOwnerTransferredNotification(req *pbGroup.TransferGroupOwnerReq) {
GroupOwnerTransferredTips := open_im_sdk.GroupOwnerTransferredTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}, NewGroupOwner: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, GroupOwnerTransferredTips.Group); err != nil {
log.NewError(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(ApplicationProcessedTips)
tips.DefaultTips = "MemberInvitedNotification"
var n NotificationMsg
n.SendID = opUserID
n.ContentType = constant.MemberInvitedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
n.Content, _ = json.Marshal(tips)
n.RecvID = groupID
Notification(&n)
if err := setOpUserInfo(req.OpUserID, req.GroupID, GroupOwnerTransferredTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed", req.OpUserID, req.GroupID)
return
}
if err := setGroupMemberInfo(req.GroupID, req.NewOwnerUserID, GroupOwnerTransferredTips.NewGroupOwner); err != nil {
log.Error(req.OperationID, "setGroupMemberInfo failed", req.GroupID, req.NewOwnerUserID)
return
}
groupNotification(constant.GroupOwnerTransferredNotification, &GroupOwnerTransferredTips, req.OpUserID, "", req.NewOwnerUserID, req.OperationID)
}
//message MemberKickedTips{
@ -235,11 +282,11 @@ func MemberInvitedNotification(operationID, groupID, opUserID, reason string, in
func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList []string) {
MemberKickedTips := open_im_sdk.MemberKickedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberKickedTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberKickedTips.Group)
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberKickedTips.OpUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberKickedTips.OpUser)
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID)
return
}
for _, v := range kickedUserIDList {
@ -250,60 +297,48 @@ func MemberKickedNotification(req *pbGroup.KickGroupMemberReq, kickedUserIDList
}
MemberKickedTips.KickedUserList = append(MemberKickedTips.KickedUserList, &groupMemberInfo)
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberKickedTips)
tips.DefaultTips = "MemberKickedNotification"
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberKickedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n)
groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, req.GroupID, "", req.OperationID)
for _, v := range kickedUserIDList {
m := n
m.SessionType = constant.SingleChatType
m.RecvID = v
Notification(&m)
groupNotification(constant.MemberKickedNotification, &MemberKickedTips, req.OpUserID, "", v, req.OperationID)
}
}
//message MemberInvitedTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo OpUser = 2;
// GroupMemberFullInfo InvitedUser = 3;
// uint64 OperationTime = 4;
//}
//被邀请进群后调用
func MemberInvitedNotification(operationID, groupID, opUserID, reason string, invitedUserIDList []string) {
MemberInvitedTips := open_im_sdk.MemberInvitedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, MemberInvitedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
return
}
if err := setOpUserInfo(opUserID, groupID, MemberInvitedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
return
}
for _, v := range invitedUserIDList {
var groupMemberInfo open_im_sdk.GroupMemberFullInfo
if err := setGroupMemberInfo(groupID, v, &groupMemberInfo); err != nil {
log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID)
continue
}
MemberInvitedTips.InvitedUserList = append(MemberInvitedTips.InvitedUserList, &groupMemberInfo)
}
groupNotification(constant.MemberInvitedNotification, &MemberInvitedTips, opUserID, groupID, "", operationID)
}
//message GroupInfoChangedTips{
// int32 ChangedType = 1; //bitwise operators: 1:groupName; 10:Notification 100:Introduction; 1000:FaceUrl
// GroupInfo Group = 2;
// GroupMemberFullInfo OpUser = 3;
//}
//群信息改变后掉用
func GroupInfoChangedNotification(operationID, opUserID, groupID string, changedType int32) {
GroupInfoChangedTips := open_im_sdk.GroupInfoChangedTips{Group: &open_im_sdk.GroupInfo{}, OpUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(groupID, GroupInfoChangedTips.Group); err != nil {
log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID, GroupInfoChangedTips.Group)
return
}
if err := setOpUserInfo(opUserID, groupID, GroupInfoChangedTips.OpUser); err != nil {
log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID, GroupInfoChangedTips.OpUser)
return
}
GroupInfoChangedTips.ChangedType = changedType
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(GroupInfoChangedTips)
tips.DefaultTips = "GroupInfoChangedNotification"
var n NotificationMsg
n.SendID = opUserID
n.ContentType = constant.GroupInfoChangedNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = operationID
n.Content, _ = json.Marshal(tips)
n.RecvID = groupID
Notification(&n)
}
//message MemberLeaveTips{
// GroupInfo Group = 1;
// GroupMemberFullInfo LeaverUser = 2;
@ -311,35 +346,6 @@ func GroupInfoChangedNotification(operationID, opUserID, groupID string, changed
//}
//群成员退群后调用
func MemberLeaveNotification(req *pbGroup.QuitGroupReq) {
MemberLeaveTips := open_im_sdk.MemberLeaveTips{Group: &open_im_sdk.GroupInfo{}, LeaverUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberLeaveTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberLeaveTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberLeaveTips.LeaverUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberLeaveTips.LeaverUser)
return
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberLeaveTips)
tips.DefaultTips = "MemberLeaveNotification"
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberLeaveNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n)
m := n
n.SessionType = constant.SingleChatType
n.RecvID = req.OpUserID
Notification(&m)
}
//message MemberEnterTips{
// GroupInfo Group = 1;
@ -348,25 +354,15 @@ func MemberLeaveNotification(req *pbGroup.QuitGroupReq) {
//}
//群成员主动申请进群，管理员同意后调用，
func MemberEnterNotification(req *pbGroup.GroupApplicationResponseReq) {
MemberLeaveTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberLeaveTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberLeaveTips.Group)
MemberEnterTips := open_im_sdk.MemberEnterTips{Group: &open_im_sdk.GroupInfo{}, EntrantUser: &open_im_sdk.GroupMemberFullInfo{}}
if err := setGroupInfo(req.GroupID, MemberEnterTips.Group); err != nil {
log.Error(req.OperationID, "setGroupInfo failed ", err.Error(), req.GroupID, MemberEnterTips.Group)
return
}
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberLeaveTips.EntrantUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberLeaveTips.EntrantUser)
if err := setOpUserInfo(req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser); err != nil {
log.Error(req.OperationID, "setOpUserInfo failed ", err.Error(), req.OpUserID, req.GroupID, MemberEnterTips.EntrantUser)
return
}
var tips open_im_sdk.TipsComm
tips.Detail, _ = json.Marshal(MemberLeaveTips)
tips.DefaultTips = "MemberEnterNotification"
var n NotificationMsg
n.SendID = req.OpUserID
n.ContentType = constant.MemberEnterNotification
n.SessionType = constant.GroupChatType
n.MsgFrom = constant.SysMsgType
n.OperationID = req.OperationID
n.Content, _ = json.Marshal(tips)
n.RecvID = req.GroupID
Notification(&n)
groupNotification(constant.MemberEnterNotification, &MemberEnterTips, req.OpUserID, req.GroupID, "", req.OperationID)
}

43
pkg/common/constant/constant.go
View File

@ -46,35 +46,27 @@ const (
//SysRelated
FriendApplicationApprovedNotification = 1201
FriendApplicationRejectedNotification = 1202
FriendApplicationAddedNotification = 1203 //AddFriendTip = 202
FriendApplicationApprovedNotification = 1201 //add_friend_response
FriendApplicationRejectedNotification = 1202 //add_friend_response
FriendApplicationNotification = 1203 //add_friend
FriendAddedNotification = 1204
FriendDeletedNotification = 1205
FriendInfoChangedNotification = 1206
BlackAddedNotification = 1207
BlackDeletedNotification = 1208
FriendDeletedNotification = 1205 //delete_friend
FriendRemarkSetNotification = 1206 //set_friend_remark?
BlackAddedNotification = 1207 //add_black
BlackDeletedNotification = 1208 //remove_black
SelfInfoUpdatedNotification = 1303 //SetSelfInfoTip = 204
GroupCreatedNotification = 1501
MemberInfoSetNotification = 1501
JoinGroupApplicationNotification = 1501
MemberQuitNotification = 1501
GroupApplicationAcceptedNotification = 1501
GroupApplicationRejectedNotification = 1501
GroupOwnerTransferredNotification = 1501
MemberKickedNotification = 1501
MemberInvitedNotification = 1501
//GroupCreatedNotification = 1501
//JoinApplicationNotification = 1502
//ApplicationProcessedNotification = 1503
//MemberInvitedNotification = 1504
//MemberKickedNotification = 1505
//GroupInfoChangedNotification = 1506
//MemberLeaveNotification = 1507
//MemberEnterNotification = 1508
GroupInfoSetNotification = 1502
JoinGroupApplicationNotification = 1503
MemberQuitNotification = 1504
GroupApplicationAcceptedNotification = 1505
GroupApplicationRejectedNotification = 1506
GroupOwnerTransferredNotification = 1507
MemberKickedNotification = 1508
MemberInvitedNotification = 1509
MemberEnterNotification = 1510
//MsgFrom
UserMsgType = 100
@ -140,6 +132,9 @@ const (
GroupResponseAgree = 1
GroupResponseRefuse = -1
FriendResponseAgree = 1
FriendResponseRefuse = -1
Male = 1
Female = 2
)

1219
pkg/proto/sdk_ws/ws.pb.go
View File

File diff suppressed because it is too large Load Diff

48
pkg/proto/sdk_ws/ws.proto
View File

@ -228,13 +228,14 @@ message TipsComm{
// OnGroupCreated()
message GroupCreatedTips{
GroupInfo group = 1;
GroupMemberFullInfo creator = 2;
GroupMemberFullInfo opUser = 2;
repeated GroupMemberFullInfo memberList = 3;
int64 operationTime = 4;
GroupMemberFullInfo groupOwnerUser = 5;
}
// OnGroupInfoSet()
message MemberInfoSetTips{
message GroupInfoSetTips{
GroupMemberFullInfo opUser = 1; //who do this
int64 muteTime = 2;
GroupInfo group = 3;
@ -244,7 +245,7 @@ message MemberInfoSetTips{
message JoinGroupApplicationTips{
GroupInfo group = 1;
PublicUserInfo applicant = 2;
string reason = 3;
string reqMsg = 3;
}
// OnQuitGroup()
@ -296,29 +297,10 @@ message MemberInvitedTips{
}
//Actively join the group
//message MemberEnterTips{
// GroupInfo group = 1;
// GroupMemberFullInfo entrantUser = 2;
// int64 operationTime = 3;
//}
message GroupInfoChangedTips{
int32 changedType = 1; //bitwise operators: 0001:groupName; 0010:Notification 0100:Introduction; 1000:FaceUrl
GroupInfo group = 2;
GroupMemberFullInfo opUser = 3;
}
message JoinGroupApplicationTips{
message MemberEnterTips{
GroupInfo group = 1;
PublicUserInfo applicant = 2;
string reason = 3;
GroupMemberFullInfo entrantUser = 2;
int64 operationTime = 3;
}
@ -326,6 +308,11 @@ message JoinGroupApplicationTips{
//////////////////////friend/////////////////////
//message FriendInfo{
// UserInfo OwnerUser = 1;
@ -351,11 +338,18 @@ message FriendApplicationAddedTips{
}
//FromUserID accept or reject ToUserID
message FriendApplicationProcessedTips{
message FriendApplicationApprovedTips{
FromToUserID fromToUserID = 1;
int32 handleResult = 2;
string handleMsg = 2;
}
//FromUserID accept or reject ToUserID
message FriendApplicationRejectedTips{
FromToUserID fromToUserID = 1;
string handleMsg = 2;
}
// FromUserID Added a friend ToUserID
message FriendAddedTips{
FriendInfo friend = 1;