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

feat: save callbacks code

Browse Source
This commit is contained in:
Xinwei Xiong (cubxxw) 2024-03-13 21:10:14 +08:00
parent ecdc76bd62
commit d3df5c8d9c
3 changed files with 152 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
internal/rpc/group/callback.go
View File

@ -33,9 +33,14 @@ import (
"github.com/openimsdk/open-im-server/v3/pkg/common/http" "github.com/openimsdk/open-im-server/v3/pkg/common/http"
) )
type EventCallbackConfig struct {
CallbackUrl string
BeforeCreateGroup config.CallBackConfig
}
// CallbackBeforeCreateGroup callback before create group // CallbackBeforeCreateGroup callback before create group
func CallbackBeforeCreateGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *group.CreateGroupReq) (err error) { func CallbackBeforeCreateGroup(ctx context.Context, cfg *EventCallbackConfig, req *group.CreateGroupReq) (err error) {
if !globalConfig.Callback.CallbackBeforeCreateGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{ cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
@ -60,9 +65,11 @@ func CallbackBeforeCreateGroup(ctx context.Context, globalConfig *config.GlobalC
}) })
} }
resp := &callbackstruct.CallbackBeforeCreateGroupResp{} resp := &callbackstruct.CallbackBeforeCreateGroupResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, cbReq, resp, globalConfig.Callback.CallbackBeforeCreateGroup); err != nil {
if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
utils.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID) utils.NotNilReplace(&req.GroupInfo.GroupID, resp.GroupID)
utils.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName) utils.NotNilReplace(&req.GroupInfo.GroupName, resp.GroupName)
utils.NotNilReplace(&req.GroupInfo.Notification, resp.Notification) utils.NotNilReplace(&req.GroupInfo.Notification, resp.Notification)
@ -78,10 +85,11 @@ func CallbackBeforeCreateGroup(ctx context.Context, globalConfig *config.GlobalC
return nil return nil
} }
func CallbackAfterCreateGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *group.CreateGroupReq) (err error) { func CallbackAfterCreateGroup(ctx context.Context, cfg *EventCallbackConfig, req *group.CreateGroupReq) (err error) {
if !globalConfig.Callback.CallbackAfterCreateGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
cbReq := &callbackstruct.CallbackAfterCreateGroupReq{ cbReq := &callbackstruct.CallbackAfterCreateGroupReq{
CallbackCommand: callbackstruct.CallbackAfterCreateGroupCommand, CallbackCommand: callbackstruct.CallbackAfterCreateGroupCommand,
GroupInfo: req.GroupInfo, GroupInfo: req.GroupInfo,
@ -103,19 +111,14 @@ func CallbackAfterCreateGroup(ctx context.Context, globalConfig *config.GlobalCo
}) })
} }
resp := &callbackstruct.CallbackAfterCreateGroupResp{} resp := &callbackstruct.CallbackAfterCreateGroupResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, cbReq, resp, globalConfig.Callback.CallbackAfterCreateGroup); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackBeforeMemberJoinGroup( func CallbackBeforeMemberJoinGroup(ctx context.Context, cfg *EventCallbackConfig, groupMember *relation.GroupMemberModel, groupEx string) (err error) {
ctx context.Context, if !cfg.BeforeCreateGroup.Enable {
globalConfig *config.GlobalConfig,
groupMember *relation.GroupMemberModel,
groupEx string,
) (err error) {
if !globalConfig.Callback.CallbackBeforeMemberJoinGroup.Enable {
return nil return nil
} }
callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{ callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
@ -128,10 +131,10 @@ func CallbackBeforeMemberJoinGroup(
resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{} resp := &callbackstruct.CallbackBeforeMemberJoinGroupResp{}
err = http.CallBackPostReturn( err = http.CallBackPostReturn(
ctx, ctx,
globalConfig.Callback.CallbackUrl, cfg.CallbackUrl,
callbackReq, callbackReq,
resp, resp,
globalConfig.Callback.CallbackBeforeMemberJoinGroup, cfg.BeforeCreateGroup,
) )
if err != nil { if err != nil {
return err return err
@ -146,10 +149,11 @@ func CallbackBeforeMemberJoinGroup(
return nil return nil
} }
func CallbackBeforeSetGroupMemberInfo(ctx context.Context, globalConfig *config.GlobalConfig, req *group.SetGroupMemberInfo) (err error) { func CallbackBeforeSetGroupMemberInfo(ctx context.Context, cfg *EventCallbackConfig, req *group.SetGroupMemberInfo) (err error) {
if !globalConfig.Callback.CallbackBeforeSetGroupMemberInfo.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{ callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
CallbackCommand: callbackstruct.CallbackBeforeSetGroupMemberInfoCommand, CallbackCommand: callbackstruct.CallbackBeforeSetGroupMemberInfoCommand,
GroupID: req.GroupID, GroupID: req.GroupID,
@ -170,10 +174,10 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, globalConfig *config.
resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{} resp := &callbackstruct.CallbackBeforeSetGroupMemberInfoResp{}
err = http.CallBackPostReturn( err = http.CallBackPostReturn(
ctx, ctx,
globalConfig.Callback.CallbackUrl, cfg.CallbackUrl,
callbackReq, callbackReq,
resp, resp,
globalConfig.Callback.CallbackBeforeSetGroupMemberInfo, cfg.BeforeCreateGroup,
) )
if err != nil { if err != nil {
return err return err
@ -192,8 +196,9 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, globalConfig *config.
} }
return nil return nil
} }
func CallbackAfterSetGroupMemberInfo(ctx context.Context, globalConfig *config.GlobalConfig, req *group.SetGroupMemberInfo) (err error) {
if !globalConfig.Callback.CallbackBeforeSetGroupMemberInfo.Enable { func CallbackAfterSetGroupMemberInfo(ctx context.Context, cfg *EventCallbackConfig, req *group.SetGroupMemberInfo) (err error) {
if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
callbackReq := callbackstruct.CallbackAfterSetGroupMemberInfoReq{ callbackReq := callbackstruct.CallbackAfterSetGroupMemberInfoReq{
@ -214,14 +219,14 @@ func CallbackAfterSetGroupMemberInfo(ctx context.Context, globalConfig *config.G
callbackReq.Ex = &req.Ex.Value callbackReq.Ex = &req.Ex.Value
} }
resp := &callbackstruct.CallbackAfterSetGroupMemberInfoResp{} resp := &callbackstruct.CallbackAfterSetGroupMemberInfoResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, callbackReq, resp, globalConfig.Callback.CallbackAfterSetGroupMemberInfo); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackQuitGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *group.QuitGroupReq) (err error) { func CallbackQuitGroup(ctx context.Context, cfg *EventCallbackConfig, req *group.QuitGroupReq) (err error) {
if !globalConfig.Callback.CallbackQuitGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
cbReq := &callbackstruct.CallbackQuitGroupReq{ cbReq := &callbackstruct.CallbackQuitGroupReq{
@ -230,14 +235,14 @@ func CallbackQuitGroup(ctx context.Context, globalConfig *config.GlobalConfig, r
UserID: req.UserID, UserID: req.UserID,
} }
resp := &callbackstruct.CallbackQuitGroupResp{} resp := &callbackstruct.CallbackQuitGroupResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, cbReq, resp, globalConfig.Callback.CallbackQuitGroup); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackKillGroupMember(ctx context.Context, globalConfig *config.GlobalConfig, req *pbgroup.KickGroupMemberReq) (err error) { func CallbackKillGroupMember(ctx context.Context, cfg *EventCallbackConfig, req *pbgroup.KickGroupMemberReq) (err error) {
if !globalConfig.Callback.CallbackKillGroupMember.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
cbReq := &callbackstruct.CallbackKillGroupMemberReq{ cbReq := &callbackstruct.CallbackKillGroupMemberReq{
@ -246,41 +251,41 @@ func CallbackKillGroupMember(ctx context.Context, globalConfig *config.GlobalCon
KickedUserIDs: req.KickedUserIDs, KickedUserIDs: req.KickedUserIDs,
} }
resp := &callbackstruct.CallbackKillGroupMemberResp{} resp := &callbackstruct.CallbackKillGroupMemberResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, cbReq, resp, globalConfig.Callback.CallbackQuitGroup); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackDismissGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *callbackstruct.CallbackDisMissGroupReq) (err error) { func CallbackDismissGroup(ctx context.Context, cfg *EventCallbackConfig, req *callbackstruct.CallbackDisMissGroupReq) (err error) {
if !globalConfig.Callback.CallbackDismissGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
req.CallbackCommand = callbackstruct.CallbackDisMissGroupCommand req.CallbackCommand = callbackstruct.CallbackDisMissGroupCommand
resp := &callbackstruct.CallbackDisMissGroupResp{} resp := &callbackstruct.CallbackDisMissGroupResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, req, resp, globalConfig.Callback.CallbackQuitGroup); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, req, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackApplyJoinGroupBefore(ctx context.Context, globalConfig *config.GlobalConfig, req *callbackstruct.CallbackJoinGroupReq) (err error) { func CallbackApplyJoinGroupBefore(ctx context.Context, cfg *EventCallbackConfig, req *callbackstruct.CallbackJoinGroupReq) (err error) {
if !globalConfig.Callback.CallbackBeforeJoinGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
req.CallbackCommand = callbackstruct.CallbackBeforeJoinGroupCommand req.CallbackCommand = callbackstruct.CallbackBeforeJoinGroupCommand
resp := &callbackstruct.CallbackJoinGroupResp{} resp := &callbackstruct.CallbackJoinGroupResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, req, resp, globalConfig.Callback.CallbackBeforeJoinGroup); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, req, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackAfterTransferGroupOwner(ctx context.Context, globalConfig *config.GlobalConfig, req *pbgroup.TransferGroupOwnerReq) (err error) { func CallbackAfterTransferGroupOwner(ctx context.Context, cfg *EventCallbackConfig, req *pbgroup.TransferGroupOwnerReq) (err error) {
if !globalConfig.Callback.CallbackAfterTransferGroupOwner.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
@ -292,13 +297,13 @@ func CallbackAfterTransferGroupOwner(ctx context.Context, globalConfig *config.G
} }
resp := &callbackstruct.CallbackTransferGroupOwnerResp{} resp := &callbackstruct.CallbackTransferGroupOwnerResp{}
if err = http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, cbReq, resp, globalConfig.Callback.CallbackAfterTransferGroupOwner); err != nil { if err = http.CallBackPostReturn(ctx, cfg.CallbackUrl, cbReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackBeforeInviteUserToGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *group.InviteUserToGroupReq) (err error) { func CallbackBeforeInviteUserToGroup(ctx context.Context, cfg *EventCallbackConfig, req *group.InviteUserToGroupReq) (err error) {
if !globalConfig.Callback.CallbackBeforeInviteUserToGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
@ -313,10 +318,10 @@ func CallbackBeforeInviteUserToGroup(ctx context.Context, globalConfig *config.G
resp := &callbackstruct.CallbackBeforeInviteUserToGroupResp{} resp := &callbackstruct.CallbackBeforeInviteUserToGroupResp{}
err = http.CallBackPostReturn( err = http.CallBackPostReturn(
ctx, ctx,
globalConfig.Callback.CallbackUrl, cfg.CallbackUrl,
callbackReq, callbackReq,
resp, resp,
globalConfig.Callback.CallbackBeforeInviteUserToGroup, cfg.BeforeCreateGroup,
) )
if err != nil { if err != nil {
@ -330,8 +335,8 @@ func CallbackBeforeInviteUserToGroup(ctx context.Context, globalConfig *config.G
return nil return nil
} }
func CallbackAfterJoinGroup(ctx context.Context, globalConfig *config.GlobalConfig, req *group.JoinGroupReq) error { func CallbackAfterJoinGroup(ctx context.Context, cfg *EventCallbackConfig, req *group.JoinGroupReq) error {
if !globalConfig.Callback.CallbackAfterJoinGroup.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
callbackReq := &callbackstruct.CallbackAfterJoinGroupReq{ callbackReq := &callbackstruct.CallbackAfterJoinGroupReq{
@ -343,14 +348,14 @@ func CallbackAfterJoinGroup(ctx context.Context, globalConfig *config.GlobalConf
InviterUserID: req.InviterUserID, InviterUserID: req.InviterUserID,
} }
resp := &callbackstruct.CallbackAfterJoinGroupResp{} resp := &callbackstruct.CallbackAfterJoinGroupResp{}
if err := http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, callbackReq, resp, globalConfig.Callback.CallbackAfterJoinGroup); err != nil { if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil
} }
func CallbackBeforeSetGroupInfo(ctx context.Context, globalConfig *config.GlobalConfig, req *group.SetGroupInfoReq) error { func CallbackBeforeSetGroupInfo(ctx context.Context, cfg *EventCallbackConfig, req *group.SetGroupInfoReq) error {
if !globalConfig.Callback.CallbackBeforeSetGroupInfo.Enable { if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
callbackReq := &callbackstruct.CallbackBeforeSetGroupInfoReq{ callbackReq := &callbackstruct.CallbackBeforeSetGroupInfoReq{
@ -377,7 +382,7 @@ func CallbackBeforeSetGroupInfo(ctx context.Context, globalConfig *config.Global
} }
resp := &callbackstruct.CallbackBeforeSetGroupInfoResp{} resp := &callbackstruct.CallbackBeforeSetGroupInfoResp{}
if err := http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, callbackReq, resp, globalConfig.Callback.CallbackBeforeSetGroupInfo); err != nil { if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
@ -399,8 +404,9 @@ func CallbackBeforeSetGroupInfo(ctx context.Context, globalConfig *config.Global
utils.NotNilReplace(&req.GroupInfoForSet.Introduction, &resp.Introduction) utils.NotNilReplace(&req.GroupInfoForSet.Introduction, &resp.Introduction)
return nil return nil
} }
func CallbackAfterSetGroupInfo(ctx context.Context, globalConfig *config.GlobalConfig, req *group.SetGroupInfoReq) error {
if !globalConfig.Callback.CallbackAfterSetGroupInfo.Enable { func CallbackAfterSetGroupInfo(ctx context.Context, cfg *EventCallbackConfig, req *group.SetGroupInfoReq) error {
if !cfg.BeforeCreateGroup.Enable {
return nil return nil
} }
callbackReq := &callbackstruct.CallbackAfterSetGroupInfoReq{ callbackReq := &callbackstruct.CallbackAfterSetGroupInfoReq{
@ -424,7 +430,7 @@ func CallbackAfterSetGroupInfo(ctx context.Context, globalConfig *config.GlobalC
callbackReq.ApplyMemberFriend = &req.GroupInfoForSet.ApplyMemberFriend.Value callbackReq.ApplyMemberFriend = &req.GroupInfoForSet.ApplyMemberFriend.Value
} }
resp := &callbackstruct.CallbackAfterSetGroupInfoResp{} resp := &callbackstruct.CallbackAfterSetGroupInfoResp{}
if err := http.CallBackPostReturn(ctx, globalConfig.Callback.CallbackUrl, callbackReq, resp, globalConfig.Callback.CallbackAfterSetGroupInfo); err != nil { if err := http.CallBackPostReturn(ctx, cfg.CallbackUrl, callbackReq, resp, cfg.BeforeCreateGroup); err != nil {
return err return err
} }
return nil return nil

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

@ -216,15 +216,28 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
if len(userMap) != len(userIDs) { if len(userMap) != len(userIDs) {
return nil, errs.ErrUserIDNotFound.Wrap("user not found") return nil, errs.ErrUserIDNotFound.Wrap("user not found")
} }
config := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeCreateGroup,
}
// Callback Before create Group // Callback Before create Group
if err := CallbackBeforeCreateGroup(ctx, s.config, req); err != nil { if err := CallbackBeforeCreateGroup(ctx, config, req); err != nil {
return nil, err return nil, err
} }
var groupMembers []*relationtb.GroupMemberModel var groupMembers []*relationtb.GroupMemberModel
group := convert.Pb2DBGroupInfo(req.GroupInfo) group := convert.Pb2DBGroupInfo(req.GroupInfo)
if err := s.GenGroupID(ctx, &group.GroupID); err != nil { if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
return nil, err return nil, err
} }
beforeCreateGroupConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
joinGroup := func(userID string, roleLevel int32) error { joinGroup := func(userID string, roleLevel int32) error {
groupMember := &relationtb.GroupMemberModel{ groupMember := &relationtb.GroupMemberModel{
GroupID: group.GroupID, GroupID: group.GroupID,
@ -236,7 +249,8 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
JoinTime: time.Now(), JoinTime: time.Now(),
MuteEndTime: time.UnixMilli(0), MuteEndTime: time.UnixMilli(0),
} }
if err := CallbackBeforeMemberJoinGroup(ctx, s.config, groupMember, group.Ex); err != nil {
if err := CallbackBeforeMemberJoinGroup(ctx, beforeCreateGroupConfig, groupMember, group.Ex); err != nil {
return err return err
} }
groupMembers = append(groupMembers, groupMember) groupMembers = append(groupMembers, groupMember)
@ -259,6 +273,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
return nil, err return nil, err
} }
resp := &pbgroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}} resp := &pbgroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
resp.GroupInfo = convert.Db2PbGroupInfo(group, req.OwnerUserID, uint32(len(userIDs))) resp.GroupInfo = convert.Db2PbGroupInfo(group, req.OwnerUserID, uint32(len(userIDs)))
resp.GroupInfo.MemberCount = uint32(len(userIDs)) resp.GroupInfo.MemberCount = uint32(len(userIDs))
tips := &sdkws.GroupCreatedTips{ tips := &sdkws.GroupCreatedTips{
@ -297,6 +312,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
} }
s.Notification.GroupCreatedNotification(ctx, tips) s.Notification.GroupCreatedNotification(ctx, tips)
} }
afterCreateGroupConfig := beforeCreateGroupConfig
reqCallBackAfter := &pbgroup.CreateGroupReq{ reqCallBackAfter := &pbgroup.CreateGroupReq{
MemberUserIDs: userIDs, MemberUserIDs: userIDs,
GroupInfo: resp.GroupInfo, GroupInfo: resp.GroupInfo,
@ -304,7 +322,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
AdminUserIDs: req.AdminUserIDs, AdminUserIDs: req.AdminUserIDs,
} }
if err := CallbackAfterCreateGroup(ctx, s.config, reqCallBackAfter); err != nil { if err := CallbackAfterCreateGroup(ctx, afterCreateGroupConfig, reqCallBackAfter); err != nil {
return nil, err return nil, err
} }
@ -395,9 +413,15 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
} }
} }
if err := CallbackBeforeInviteUserToGroup(ctx, s.config, req); err != nil { beforeInviteUserToGroupConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeInviteUserToGroup,
}
if err := CallbackBeforeInviteUserToGroup(ctx, beforeInviteUserToGroupConfig, req); err != nil {
return nil, err return nil, err
} }
if group.NeedVerification == constant.AllNeedVerification { if group.NeedVerification == constant.AllNeedVerification {
if !authverify.IsAppManagerUid(ctx, s.config) { if !authverify.IsAppManagerUid(ctx, s.config) {
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) { if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
@ -439,7 +463,10 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
JoinTime: time.Now(), JoinTime: time.Now(),
MuteEndTime: time.UnixMilli(0), MuteEndTime: time.UnixMilli(0),
} }
if err := CallbackBeforeMemberJoinGroup(ctx, s.config, member, group.Ex); err != nil {
beforeMemberJoinGroupConfig := beforeInviteUserToGroupConfig
if err := CallbackBeforeMemberJoinGroup(ctx, beforeMemberJoinGroupConfig, member, group.Ex); err != nil {
return nil, err return nil, err
} }
groupMembers = append(groupMembers, member) groupMembers = append(groupMembers, member)
@ -611,7 +638,12 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
return nil, err return nil, err
} }
if err := CallbackKillGroupMember(ctx, s.config, req); err != nil { killGroupMemberConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err := CallbackKillGroupMember(ctx, killGroupMemberConfig, req); err != nil {
return nil, err return nil, err
} }
return resp, nil return resp, nil
@ -781,7 +813,13 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
OperatorUserID: mcontext.GetOpUserID(ctx), OperatorUserID: mcontext.GetOpUserID(ctx),
Ex: groupRequest.Ex, Ex: groupRequest.Ex,
} }
if err = CallbackBeforeMemberJoinGroup(ctx, s.config, member, group.Ex); err != nil {
beforeMemberJoinGroupConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err = CallbackBeforeMemberJoinGroup(ctx, beforeMemberJoinGroupConfig, member, group.Ex); err != nil {
return nil, err return nil, err
} }
} }
@ -829,7 +867,12 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
Ex: req.Ex, Ex: req.Ex,
} }
if err = CallbackApplyJoinGroupBefore(ctx, s.config, reqCall); err != nil { applyJoinGroupBeforeConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err = CallbackApplyJoinGroupBefore(ctx, applyJoinGroupBeforeConfig, reqCall); err != nil {
return nil, err return nil, err
} }
_, err = s.db.TakeGroupMember(ctx, req.GroupID, req.InviterUserID) _, err = s.db.TakeGroupMember(ctx, req.GroupID, req.InviterUserID)
@ -850,7 +893,8 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
JoinTime: time.Now(), JoinTime: time.Now(),
MuteEndTime: time.UnixMilli(0), MuteEndTime: time.UnixMilli(0),
} }
if err := CallbackBeforeMemberJoinGroup(ctx, s.config, groupMember, group.Ex); err != nil { MemberJoinGroupConfig := applyJoinGroupBeforeConfig
if err := CallbackBeforeMemberJoinGroup(ctx, MemberJoinGroupConfig, groupMember, group.Ex); err != nil {
return nil, err return nil, err
} }
if err := s.db.CreateGroup(ctx, nil, []*relationtb.GroupMemberModel{groupMember}); err != nil { if err := s.db.CreateGroup(ctx, nil, []*relationtb.GroupMemberModel{groupMember}); err != nil {
@ -861,7 +905,8 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq)
return nil, err return nil, err
} }
s.Notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID) s.Notification.MemberEnterNotification(ctx, req.GroupID, req.InviterUserID)
if err = CallbackAfterJoinGroup(ctx, s.config, req); err != nil { afterJoinGroupConfig := applyJoinGroupBeforeConfig
if err = CallbackAfterJoinGroup(ctx, afterJoinGroupConfig, req); err != nil {
return nil, err return nil, err
} }
return resp, nil return resp, nil
@ -910,8 +955,12 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
return nil, err return nil, err
} }
// callback quitGroupConfig := &EventCallbackConfig{
if err := CallbackQuitGroup(ctx, s.config, req); err != nil { CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err := CallbackQuitGroup(ctx, quitGroupConfig, req); err != nil {
return nil, err return nil, err
} }
return resp, nil return resp, nil
@ -941,7 +990,13 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
return nil, err return nil, err
} }
} }
if err := CallbackBeforeSetGroupInfo(ctx, s.config, req); err != nil {
beforeSetGroupInfoConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err := CallbackBeforeSetGroupInfo(ctx, beforeSetGroupInfoConfig, req); err != nil {
return nil, err return nil, err
} }
group, err := s.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID) group, err := s.db.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
@ -1010,7 +1065,9 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
if num > 0 { if num > 0 {
_ = s.Notification.GroupInfoSetNotification(ctx, tips) _ = s.Notification.GroupInfoSetNotification(ctx, tips)
} }
if err := CallbackAfterSetGroupInfo(ctx, s.config, req); err != nil {
afterSetGroupInfoConfig := beforeSetGroupInfoConfig
if err := CallbackAfterSetGroupInfo(ctx, afterSetGroupInfoConfig, req); err != nil {
return nil, err return nil, err
} }
return resp, nil return resp, nil
@ -1056,7 +1113,12 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
return nil, err return nil, err
} }
if err := CallbackAfterTransferGroupOwner(ctx, s.config, req); err != nil { afterTransferGroupOwnerConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err := CallbackAfterTransferGroupOwner(ctx, afterTransferGroupOwnerConfig, req); err != nil {
return nil, err return nil, err
} }
s.Notification.GroupOwnerTransferredNotification(ctx, req) s.Notification.GroupOwnerTransferredNotification(ctx, req)
@ -1223,7 +1285,13 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
MembersID: membersID, MembersID: membersID,
GroupType: string(group.GroupType), GroupType: string(group.GroupType),
} }
if err := CallbackDismissGroup(ctx, s.config, reqCall); err != nil {
dismissGroupConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
if err := CallbackDismissGroup(ctx, dismissGroupConfig, reqCall); err != nil {
return nil, err return nil, err
} }
@ -1414,8 +1482,14 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
return nil, errs.ErrArgs.Wrap("user not in group") return nil, errs.ErrArgs.Wrap("user not in group")
} }
} }
beforeSetGroupMemberInfoConfig := &EventCallbackConfig{
CallbackUrl: s.config.Callback.CallbackUrl,
BeforeCreateGroup: s.config.Callback.CallbackBeforeMemberJoinGroup,
}
for i := 0; i < len(req.Members); i++ { for i := 0; i < len(req.Members); i++ {
if err := CallbackBeforeSetGroupMemberInfo(ctx, s.config, req.Members[i]); err != nil { if err := CallbackBeforeSetGroupMemberInfo(ctx, beforeSetGroupMemberInfoConfig, req.Members[i]); err != nil {
return nil, err return nil, err
} }
} }
@ -1441,8 +1515,9 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbgroup.SetGr
s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID) s.Notification.GroupMemberInfoSetNotification(ctx, member.GroupID, member.UserID)
} }
} }
afterSetGroupMemberInfoConfig := beforeSetGroupMemberInfoConfig
for i := 0; i < len(req.Members); i++ { for i := 0; i < len(req.Members); i++ {
if err := CallbackAfterSetGroupMemberInfo(ctx, s.config, req.Members[i]); err != nil { if err := CallbackAfterSetGroupMemberInfo(ctx, afterSetGroupMemberInfoConfig, req.Members[i]); err != nil {
return nil, err return nil, err
} }
} }

3
pkg/common/config/config.go
View File

@ -118,6 +118,7 @@ type Minio struct {
SignEndpoint string `yaml:"signEndpoint"` SignEndpoint string `yaml:"signEndpoint"`
PublicRead bool `yaml:"publicRead"` PublicRead bool `yaml:"publicRead"`
} }
type Cos struct { type Cos struct {
BucketURL string `yaml:"bucketURL"` BucketURL string `yaml:"bucketURL"`
SecretID string `yaml:"secretID"` SecretID string `yaml:"secretID"`
@ -125,6 +126,7 @@ type Cos struct {
SessionToken string `yaml:"sessionToken"` SessionToken string `yaml:"sessionToken"`
PublicRead bool `yaml:"publicRead"` PublicRead bool `yaml:"publicRead"`
} }
type Oss struct { type Oss struct {
Endpoint string `yaml:"endpoint"` Endpoint string `yaml:"endpoint"`
Bucket string `yaml:"bucket"` Bucket string `yaml:"bucket"`
@ -134,6 +136,7 @@ type Oss struct {
SessionToken string `yaml:"sessionToken"` SessionToken string `yaml:"sessionToken"`
PublicRead bool `yaml:"publicRead"` PublicRead bool `yaml:"publicRead"`
} }
type Kodo struct { type Kodo struct {
Endpoint string `yaml:"endpoint"` Endpoint string `yaml:"endpoint"`
Bucket string `yaml:"bucket"` Bucket string `yaml:"bucket"`