msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

errcode

Browse Source
test-errcode
wangchuxiao 3 years ago
parent d6edb4aa8c
commit 21a1e7dff2
23 changed files with 173 additions and 285 deletions
Show Stats Download Patch File Download Diff File

12
internal/api/group/group.go
Unescape View File

@ -996,15 +996,15 @@ func MuteGroupMember(c *gin.Context) {
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等" // @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /group/cancel_mute_group_member [post] // @Router /group/cancel_mute_group_member [post]
func CancelMuteGroupMember(c *gin.Context) { func CancelMuteGroupMember(c *gin.Context) {
nCtx := trace_log.NewCtx(c, utils.GetSelfFuncName()) nCtx := tracelog.NewCtx(c, utils.GetSelfFuncName())
defer log.ShowLog(c) defer log.ShowLog(c)
params := api.CancelMuteGroupMemberReq{} params := api.CancelMuteGroupMemberReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
trace_log.WriteErrorResponse(nCtx, "BindJSON", err) tracelog.WriteErrorResponse(nCtx, "BindJSON", err)
return return
} }
trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", params) tracelog.SetCtxInfo(nCtx, "BindJSON", nil, "params", params)
req := &rpc.CancelMuteGroupMemberReq{} req := &rpc.CancelMuteGroupMemberReq{}
utils.CopyStructFields(req, &params) utils.CopyStructFields(req, &params)
@ -1013,18 +1013,18 @@ func CancelMuteGroupMember(c *gin.Context) {
// trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err) // trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err)
// return // return
//} //}
trace_log.SetCtxInfo(nCtx, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID) tracelog.SetCtxInfo(nCtx, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID)
etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID) etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
client := rpc.NewGroupClient(etcdConn) client := rpc.NewGroupClient(etcdConn)
reply, err := client.CancelMuteGroupMember(nCtx, req) reply, err := client.CancelMuteGroupMember(nCtx, req)
if err != nil { if err != nil {
trace_log.WriteErrorResponse(nCtx, "CancelMuteGroupMember", err) tracelog.WriteErrorResponse(nCtx, "CancelMuteGroupMember", err)
return return
} }
trace_log.SetCtxInfo(nCtx, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String()) tracelog.SetCtxInfo(nCtx, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String())
resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}} resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
} }

16
internal/api_to_rpc/api.go
Unescape View File

@ -16,16 +16,16 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl
rpcName = utils2.GetFuncName(1) rpcName = utils2.GetFuncName(1)
} }
logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName) logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
ctx := trace_log.NewCtx1(c, rpcFuncName) ctx := tracelog.NewCtx1(c, rpcFuncName)
defer log.ShowLog(ctx) defer log.ShowLog(ctx)
if err := c.BindJSON(apiReq); err != nil { if err := c.BindJSON(apiReq); err != nil {
trace_log.WriteErrorResponse(ctx, "BindJSON", err) tracelog.WriteErrorResponse(ctx, "BindJSON", err)
return return
} }
trace_log.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq) tracelog.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
etcdConn, err := getcdv3.GetConn(ctx, rpcName) etcdConn, err := getcdv3.GetConn(ctx, rpcName)
if err != nil { if err != nil {
trace_log.WriteErrorResponse(ctx, "GetConn", err) tracelog.WriteErrorResponse(ctx, "GetConn", err)
return return
} }
rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{ rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
@ -33,22 +33,22 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl
})[0].MethodByName(rpcFuncName) // rpcClient func })[0].MethodByName(rpcFuncName) // rpcClient func
rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req
CopyAny(apiReq, rpcReqPtr.Interface()) CopyAny(apiReq, rpcReqPtr.Interface())
trace_log.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface())) tracelog.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
respArr := rpcClient.Call([]reflect.Value{ respArr := rpcClient.Call([]reflect.Value{
reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID) reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID)
rpcReqPtr, // rpcClient apiReq rpcReqPtr, // rpcClient apiReq
}) // respArr => (apiResp, error) }) // respArr => (apiResp, error)
if !respArr[1].IsNil() { // rpcClient err != nil if !respArr[1].IsNil() { // rpcClient err != nil
err := respArr[1].Interface().(error) err := respArr[1].Interface().(error)
trace_log.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error") tracelog.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
return return
} }
rpcResp := respArr[0].Elem() rpcResp := respArr[0].Elem()
trace_log.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface())) tracelog.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
if apiResp != nil { if apiResp != nil {
CopyAny(rpcResp.Interface(), apiResp) CopyAny(rpcResp.Interface(), apiResp)
} }
trace_log.SetSuccess(ctx, rpcFuncName, apiResp) tracelog.SetSuccess(ctx, rpcFuncName, apiResp)
} }
func rpcString(v interface{}) string { func rpcString(v interface{}) string {

2
internal/cron_task/cron_task.go
Unescape View File

@ -18,7 +18,7 @@ const cronTaskOperationID = "cronTaskOperationID-"
func StartCronTask(userID, workingGroupID string) { func StartCronTask(userID, workingGroupID string) {
log.NewPrivateLog("cron") log.NewPrivateLog("cron")
log.NewInfo(utils.OperationIDGenerator(), "start cron task", "cron config", config.Config.Mongo.ChatRecordsClearTime) log.NewInfo(utils.OperationIDGenerator(), "start cron task", "cron config", config.Config.Mongo.ChatRecordsClearTime)
fmt.Println("cron config", config.Config.Mongo.ChatRecordsClearTime) fmt.Println("cron task start, config", config.Config.Mongo.ChatRecordsClearTime)
if userID != "" { if userID != "" {
operationID := getCronTaskOperationID() operationID := getCronTaskOperationID()
StartClearMsg(operationID, []string{userID}) StartClearMsg(operationID, []string{userID})

6
internal/cron_task/test/main.go
Unescape View File

@ -1,6 +0,0 @@
package main
//
//func main() {
// db.DB.BatchInsertChat()
//}

150
internal/rpc/admin_cms/admin_cms.go
Unescape View File

@ -3,9 +3,11 @@ package admin_cms
import ( import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db/controller"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
promePkg "Open_IM/pkg/common/prometheus" promePkg "Open_IM/pkg/common/prometheus"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/common/tracelog"
"Open_IM/pkg/getcdv3" "Open_IM/pkg/getcdv3"
pbAdminCMS "Open_IM/pkg/proto/admin_cms" pbAdminCMS "Open_IM/pkg/proto/admin_cms"
server_api_params "Open_IM/pkg/proto/sdk_ws" server_api_params "Open_IM/pkg/proto/sdk_ws"
@ -26,10 +28,13 @@ import (
) )
type adminCMSServer struct { type adminCMSServer struct {
rpcPort int rpcPort int
rpcRegisterName string rpcRegisterName string
etcdSchema string etcdSchema string
etcdAddr []string etcdAddr []string
adminCMSInterface controller.AdminCMSInterface
groupInterface controller.GroupInterface
userInterface controller.UserInterface
} }
func NewAdminCMSServer(port int) *adminCMSServer { func NewAdminCMSServer(port int) *adminCMSServer {
@ -82,7 +87,7 @@ func (s *adminCMSServer) Run() {
} }
} }
log.NewInfo("", "rpcRegisterIP ", rpcRegisterIP) log.NewInfo("", "rpcRegisterIP ", rpcRegisterIP)
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10) err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
if err != nil { if err != nil {
log.NewError("0", "RegisterEtcd failed ", err.Error()) log.NewError("0", "RegisterEtcd failed ", err.Error())
panic(utils.Wrap(err, "register admin module rpc to etcd err")) panic(utils.Wrap(err, "register admin module rpc to etcd err"))
@ -95,35 +100,27 @@ func (s *adminCMSServer) Run() {
log.NewInfo("0", "message cms rpc success") log.NewInfo("0", "message cms rpc success")
} }
func (s *adminCMSServer) AdminLogin(_ context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) { func (s *adminCMSServer) AdminLogin(ctx context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) resp := &pbAdminCMS.AdminLoginResp{}
resp := &pbAdminCMS.AdminLoginResp{CommonResp: &pbAdminCMS.CommonResp{}}
for i, adminID := range config.Config.Manager.AppManagerUid { for i, adminID := range config.Config.Manager.AppManagerUid {
if adminID == req.AdminID && config.Config.Manager.Secrets[i] == req.Secret { if adminID == req.AdminID && config.Config.Manager.Secrets[i] == req.Secret {
token, expTime, err := token_verify.CreateToken(adminID, constant.SingleChatType) token, expTime, err := token_verify.CreateToken(adminID, constant.LinuxPlatformID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error()) log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error())
resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode return nil, err
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime) log.NewInfo(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime)
resp.Token = token resp.Token = token
break break
} }
} }
if resp.Token == "" { if resp.Token == "" {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed") log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed")
resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode return nil, constant.ErrInternalServer
resp.CommonResp.ErrMsg = constant.ErrTokenMalformed.ErrMsg
return resp, nil
} }
admin, err := imdb.GetUserByUserID(req.AdminID) admin, err := s.userInterface.Take(ctx, req.AdminID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed", req.AdminID, err.Error()) return nil, err
resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
resp.UserName = admin.Nickname resp.UserName = admin.Nickname
resp.FaceURL = admin.FaceURL resp.FaceURL = admin.FaceURL
@ -149,67 +146,6 @@ func (s *adminCMSServer) GetUserToken(_ context.Context, req *pbAdminCMS.GetUser
return resp, nil return resp, nil
} }
func (s *adminCMSServer) AddUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.AddUserRegisterAddFriendIDListReq) (*pbAdminCMS.AddUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.AddUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
if err := imdb.AddUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
func (s *adminCMSServer) ReduceUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.ReduceUserRegisterAddFriendIDListReq) (*pbAdminCMS.ReduceUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.ReduceUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
if req.Operation == 0 {
if err := imdb.ReduceUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
}
} else {
if err := imdb.DeleteAllRegisterAddFriendIDList(); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
}
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
func (s *adminCMSServer) GetUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.GetUserRegisterAddFriendIDListReq) (*pbAdminCMS.GetUserRegisterAddFriendIDListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbAdminCMS.GetUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
userIDList, err := imdb.GetRegisterAddFriendList(req.Pagination.ShowNumber, req.Pagination.PageNumber)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
}
userList, err := imdb.GetUsersByUserIDList(userIDList)
if err != nil {
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), userList, userIDList)
resp.Pagination = &server_api_params.ResponsePagination{
CurrentPage: req.Pagination.PageNumber,
ShowNumber: req.Pagination.ShowNumber,
}
utils.CopyStructFields(&resp.UserInfoList, userList)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil
}
func (s *adminCMSServer) GetChatLogs(_ context.Context, req *pbAdminCMS.GetChatLogsReq) (*pbAdminCMS.GetChatLogsResp, error) { func (s *adminCMSServer) GetChatLogs(_ context.Context, req *pbAdminCMS.GetChatLogsReq) (*pbAdminCMS.GetChatLogsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String())
resp := &pbAdminCMS.GetChatLogsResp{CommonResp: &pbAdminCMS.CommonResp{}, Pagination: &server_api_params.ResponsePagination{}} resp := &pbAdminCMS.GetChatLogsResp{CommonResp: &pbAdminCMS.CommonResp{}, Pagination: &server_api_params.ResponsePagination{}}
@ -302,17 +238,17 @@ func (s *adminCMSServer) GetActiveGroup(_ context.Context, req *pbAdminCMS.GetAc
resp := &pbAdminCMS.GetActiveGroupResp{} resp := &pbAdminCMS.GetActiveGroupResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
if err != nil { if err != nil {
return resp, err return nil, err
} }
activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12) activeGroups, err := s.adminCMSInterface.GetActiveGroups(fromTime, toTime, 12)
if err != nil { if err != nil {
return resp, err return nil, err
} }
for _, activeGroup := range activeGroups { for _, activeGroup := range activeGroups {
resp.Groups = append(resp.Groups, resp.Groups = append(resp.Groups,
&pbAdminCMS.GroupResp{ &pbAdminCMS.GroupResp{
GroupName: activeGroup.Name, GroupName: activeGroup.Name,
GroupID: activeGroup.Id, GroupID: activeGroup.ID,
MessageNum: int32(activeGroup.MessageNum), MessageNum: int32(activeGroup.MessageNum),
}) })
} }
@ -684,43 +620,3 @@ func (s *adminCMSServer) GetUserIDByEmailAndPhoneNumber(_ context.Context, req *
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil return resp, nil
} }
func (s *adminCMSServer) GenerateInvitationCode(_ context.Context, req *pbAdminCMS.GenerateInvitationCodeReq) (*pbAdminCMS.GenerateInvitationCodeResp, error) {
return nil, nil
}
func (s *adminCMSServer) GetInvitationCodes(_ context.Context, req *pbAdminCMS.GetInvitationCodesReq) (*pbAdminCMS.GetInvitationCodesResp, error) {
return nil, nil
}
func (s *adminCMSServer) QueryIPRegister(_ context.Context, req *pbAdminCMS.QueryIPRegisterReq) (*pbAdminCMS.QueryIPRegisterResp, error) {
return nil, nil
}
func (s *adminCMSServer) AddIPLimit(_ context.Context, req *pbAdminCMS.AddIPLimitReq) (*pbAdminCMS.AddIPLimitResp, error) {
return nil, nil
}
func (s *adminCMSServer) RemoveIPLimit(_ context.Context, req *pbAdminCMS.RemoveIPLimitReq) (*pbAdminCMS.RemoveIPLimitResp, error) {
return nil, nil
}
func (s *adminCMSServer) QueryUserIDIPLimitLogin(_ context.Context, req *pbAdminCMS.QueryUserIDIPLimitLoginReq) (*pbAdminCMS.QueryUserIDIPLimitLoginResp, error) {
return nil, nil
}
func (s *adminCMSServer) AddUserIPLimitLogin(_ context.Context, req *pbAdminCMS.AddUserIPLimitLoginReq) (*pbAdminCMS.AddUserIPLimitLoginResp, error) {
return nil, nil
}
func (s *adminCMSServer) RemoveUserIPLimit(_ context.Context, req *pbAdminCMS.RemoveUserIPLimitReq) (*pbAdminCMS.RemoveUserIPLimitResp, error) {
return nil, nil
}
func (s *adminCMSServer) GetClientInitConfig(_ context.Context, req *pbAdminCMS.GetClientInitConfigReq) (*pbAdminCMS.GetClientInitConfigResp, error) {
return nil, nil
}
func (s *adminCMSServer) SetClientInitConfig(_ context.Context, req *pbAdminCMS.SetClientInitConfigReq) (*pbAdminCMS.SetClientInitConfigResp, error) {
return nil, nil
}

2
internal/rpc/friend/friend.go
Unescape View File

@ -247,7 +247,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
} else if req.HandleResult == constant.FriendResponseRefuse { } else if req.HandleResult == constant.FriendResponseRefuse {
chat.FriendApplicationRejectedNotification(req) chat.FriendApplicationRejectedNotification(req)
} else { } else {
trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult) tracelog.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult)
} }
return resp, nil return resp, nil
} }

6
internal/rpc/group/callback.go
Unescape View File

@ -16,7 +16,7 @@ import (
func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) { func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req) tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
}() }()
if !config.Config.Callback.CallbackBeforeCreateGroup.Enable { if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
return nil return nil
@ -79,7 +79,7 @@ func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq)
func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMember, groupEx string) (err error) { func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMember, groupEx string) (err error) {
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx) tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
}() }()
callbackResp := cbApi.CommonCallbackResp{OperationID: operationID} callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable { if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
@ -121,7 +121,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, grou
func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (err error) { func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (err error) {
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req) tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
}() }()
callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID} callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable { if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {

51
internal/rpc/group/group.go
Unescape View File

@ -15,6 +15,7 @@ import (
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/common/tools" "Open_IM/pkg/common/tools"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/common/tracelog"
cp "Open_IM/internal/utils" cp "Open_IM/internal/utils"
"Open_IM/pkg/getcdv3" "Open_IM/pkg/getcdv3"
@ -319,14 +320,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
resultNode.Result = 0 resultNode.Result = 0
toUserInfo, err := relation.GetUserByUserID(v) toUserInfo, err := relation.GetUserByUserID(v)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v) tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
} }
if relation.IsExistGroupMember(req.GroupID, v) { if relation.IsExistGroupMember(req.GroupID, v) {
trace_log.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v) tracelog.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -343,7 +344,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
} }
err = relation.InsertIntoGroupMember(toInsertInfo) err = relation.InsertIntoGroupMember(toInsertInfo)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo) tracelog.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -351,7 +352,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
okUserIDList = append(okUserIDList, v) okUserIDList = append(okUserIDList, v)
err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID) err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID) tracelog.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID)
} }
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
} }
@ -367,7 +368,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
} else { } else {
for _, userID := range req.InvitedUserIDList { for _, userID := range req.InvitedUserIDList {
if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
trace_log.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) tracelog.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID)
} }
} }
for _, v := range req.InvitedUserIDList { for _, v := range req.InvitedUserIDList {
@ -480,23 +481,23 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v) kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v)
if err != nil { if err != nil {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
trace_log.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v) tracelog.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
continue continue
} }
if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v) tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
continue continue
} }
if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v) tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
continue continue
} }
err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v) err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v)
trace_log.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v) tracelog.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
if err != nil { if err != nil {
log.NewError(tools.OperationID(ctx), "RemoveGroupMember failed ", err.Error(), req.GroupID, v) log.NewError(tools.OperationID(ctx), "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
@ -521,7 +522,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
} }
client := pbUser.NewUserClient(etcdConn) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) respPb, err := client.SetConversation(context.Background(), &reqPb)
trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
} }
} else { } else {
okUserIDList = req.KickedUserIDList okUserIDList = req.KickedUserIDList
@ -533,14 +534,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
for _, userID := range okUserIDList { for _, userID := range okUserIDList {
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil { if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil {
trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID) tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
} }
} }
chat.MemberKickedNotification(req, okUserIDList) chat.MemberKickedNotification(req, okUserIDList)
} else { } else {
for _, userID := range okUserIDList { for _, userID := range okUserIDList {
if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID) tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
} }
} }
go func() { go func() {
@ -599,7 +600,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
return nil, err return nil, err
} }
var errResult error var errResult error
trace_log.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply) tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
for _, v := range reply { for _, v := range reply {
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}} node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
err := FillGroupInfoByGroupID(tools.OperationID(ctx), v.GroupID, node.GroupInfo) err := FillGroupInfoByGroupID(tools.OperationID(ctx), v.GroupID, node.GroupInfo)
@ -609,7 +610,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
} }
continue continue
} }
trace_log.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo) tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
err = FillPublicUserInfoByUserID(tools.OperationID(ctx), v.UserID, node.UserInfo) err = FillPublicUserInfoByUserID(tools.OperationID(ctx), v.UserID, node.UserInfo)
if err != nil { if err != nil {
errResult = err errResult = err
@ -621,7 +622,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
if errResult != nil && len(resp.GroupRequestList) == 0 { if errResult != nil && len(resp.GroupRequestList) == 0 {
return nil, err return nil, err
} }
trace_log.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String()) tracelog.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
return resp, nil return resp, nil
} }
@ -644,7 +645,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
func CheckPermission(ctx context.Context, groupID string, userID string) (err error) { func CheckPermission(ctx context.Context, groupID string, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID) tracelog.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID)
}() }()
if !token_verify.IsManagerUserID(userID) && !relation.IsGroupOwnerAdmin(groupID, userID) { if !token_verify.IsManagerUserID(userID) && !relation.IsGroupOwnerAdmin(groupID, userID) {
return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName()) return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName())
@ -764,7 +765,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
} }
client := pbUser.NewUserClient(etcdConn) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) respPb, err := client.SetConversation(context.Background(), &reqPb)
trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb) tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
chat.MemberEnterDirectlyNotification(req.GroupID, tools.OpUserID(ctx), tools.OperationID(ctx)) chat.MemberEnterDirectlyNotification(req.GroupID, tools.OpUserID(ctx), tools.OperationID(ctx))
return resp, nil return resp, nil
} else { } else {
@ -932,7 +933,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
} }
nClient := pbConversation.NewConversationClient(nEtcdConn) nClient := pbConversation.NewConversationClient(nEtcdConn)
conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq) conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq)
trace_log.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
} }
return resp, nil return resp, nil
} }
@ -1005,14 +1006,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
} else { } else {
groups, count, err := relation.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber) groups, count, err := relation.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber) tracelog.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber)
} }
for _, v := range groups { for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}} group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v) utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := relation.GetGroupOwnerInfoByGroupID(v.GroupID) groupMember, err := relation.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID) tracelog.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
continue continue
} }
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix()) group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
@ -1061,12 +1062,12 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}} node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
group, err := relation.GetGroupInfoByGroupID(groupReq.GroupID) group, err := relation.GetGroupInfoByGroupID(groupReq.GroupID)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID) tracelog.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
continue continue
} }
user, err := relation.GetUserByUserID(groupReq.UserID) user, err := relation.GetUserByUserID(groupReq.UserID)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID) tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
continue continue
} }
cp.GroupRequestDBCopyOpenIM(&node, &groupReq) cp.GroupRequestDBCopyOpenIM(&node, &groupReq)
@ -1102,7 +1103,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
memberList, err := relation.GetGroupMemberListByGroupID(req.GroupID) memberList, err := relation.GetGroupMemberListByGroupID(req.GroupID)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID) tracelog.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID)
} }
//modify quitter conversation info //modify quitter conversation info
var reqPb pbUser.SetConversationReq var reqPb pbUser.SetConversationReq
@ -1118,7 +1119,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) respPb, err := client.SetConversation(context.Background(), &reqPb)
trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
} }
err = relation.DeleteGroupMemberByGroupID(req.GroupID) err = relation.DeleteGroupMemberByGroupID(req.GroupID)
if err != nil { if err != nil {
@ -1381,7 +1382,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
} }
func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error { func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error {
operationID := trace_log.GetOperationID(ctx) operationID := tracelog.GetOperationID(ctx)
if groupID != "" { if groupID != "" {
etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
if err != nil { if err != nil {

1
internal/utils/callback.go
Unescape View File

@ -1 +0,0 @@
package utils

6
pkg/common/db/cache/group.go vendored
Unescape View File

@ -56,7 +56,7 @@ func (g *GroupCache) GetGroupInfo(ctx context.Context, groupID string) (group *r
} }
group = &relation.Group{} group = &relation.Group{}
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
}() }()
groupStr, err := g.rcClient.Fetch(g.getGroupInfoCacheKey(groupID), g.expireTime, getGroup) groupStr, err := g.rcClient.Fetch(g.getGroupInfoCacheKey(groupID), g.expireTime, getGroup)
if err != nil { if err != nil {
@ -68,7 +68,7 @@ func (g *GroupCache) GetGroupInfo(ctx context.Context, groupID string) (group *r
func (g *GroupCache) DelGroupInfo(ctx context.Context, groupID string) (err error) { func (g *GroupCache) DelGroupInfo(ctx context.Context, groupID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
}() }()
return g.rcClient.TagAsDeleted(g.getGroupInfoCacheKey(groupID)) return g.rcClient.TagAsDeleted(g.getGroupInfoCacheKey(groupID))
} }
@ -96,7 +96,7 @@ func (g *GroupCache) DelJoinedSuperGroupIDs(ctx context.Context, userIDs []strin
func (g *GroupCache) DelJoinedSuperGroupID(ctx context.Context, userID string) (err error) { func (g *GroupCache) DelJoinedSuperGroupID(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return g.rcClient.TagAsDeleted(joinedSuperGroupListCache + userID) return g.rcClient.TagAsDeleted(joinedSuperGroupListCache + userID)
} }

62
pkg/common/db/cache/rockscache.go vendored
Unescape View File

@ -85,7 +85,7 @@ func (rc *Client) GetFriendIDListFromCache(ctx context.Context, userID string) (
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList)
}() }()
friendIDListStr, err := db.DB.Rc.Fetch(friendRelationCache+userID, time.Second*30*60, getFriendIDList) friendIDListStr, err := db.DB.Rc.Fetch(friendRelationCache+userID, time.Second*30*60, getFriendIDList)
if err != nil { if err != nil {
@ -97,7 +97,7 @@ func (rc *Client) GetFriendIDListFromCache(ctx context.Context, userID string) (
func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) { func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(friendRelationCache + userID) return db.DB.Rc.TagAsDeleted(friendRelationCache + userID)
} }
@ -115,7 +115,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDs []strin
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs)
}() }()
blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList) blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList)
if err != nil { if err != nil {
@ -127,7 +127,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDs []strin
func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) { func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx)
}() }()
return db.DB.Rc.TagAsDeleted(blackListCache + userID) return db.DB.Rc.TagAsDeleted(blackListCache + userID)
} }
@ -145,7 +145,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList)
}() }()
joinedGroupIDListStr, err := db.DB.Rc.Fetch(joinedGroupListCache+userID, time.Second*30*60, getJoinedGroupIDList) joinedGroupIDListStr, err := db.DB.Rc.Fetch(joinedGroupListCache+userID, time.Second*30*60, getJoinedGroupIDList)
if err != nil { if err != nil {
@ -157,7 +157,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) { func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID) return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID)
} }
@ -188,7 +188,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList)
}() }()
groupIDListStr, err := db.DB.Rc.Fetch(groupCache+groupID, time.Second*30*60, f) groupIDListStr, err := db.DB.Rc.Fetch(groupCache+groupID, time.Second*30*60, f)
if err != nil { if err != nil {
@ -200,7 +200,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) { func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
}() }()
return db.DB.Rc.TagAsDeleted(groupCache + groupID) return db.DB.Rc.TagAsDeleted(groupCache + groupID)
} }
@ -218,7 +218,7 @@ func GetUserInfoFromCache(ctx context.Context, userID string) (userInfo *relatio
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo)
}() }()
userInfoStr, err := db.DB.Rc.Fetch(userInfoCache+userID, time.Second*30*60, getUserInfo) userInfoStr, err := db.DB.Rc.Fetch(userInfoCache+userID, time.Second*30*60, getUserInfo)
if err != nil { if err != nil {
@ -243,7 +243,7 @@ func GetUserInfoFromCacheBatch(ctx context.Context, userIDs []string) ([]*relati
func DelUserInfoFromCache(ctx context.Context, userID string) (err error) { func DelUserInfoFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(userInfoCache + userID) return db.DB.Rc.TagAsDeleted(userInfoCache + userID)
} }
@ -261,7 +261,7 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
}() }()
groupMemberInfoStr, err := db.DB.Rc.Fetch(groupMemberInfoCache+groupID+"-"+userID, time.Second*30*60, getGroupMemberInfo) groupMemberInfoStr, err := db.DB.Rc.Fetch(groupMemberInfoCache+groupID+"-"+userID, time.Second*30*60, getGroupMemberInfo)
if err != nil { if err != nil {
@ -274,14 +274,14 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g
func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) { func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(groupMemberInfoCache + groupID + "-" + userID) return db.DB.Rc.TagAsDeleted(groupMemberInfoCache + groupID + "-" + userID)
} }
func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relation.GroupMember, err error) { func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relation.GroupMember, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers)
}() }()
groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID) groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID)
if err != nil { if err != nil {
@ -328,7 +328,7 @@ func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, grou
func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*relation.GroupMember, err error) { func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*relation.GroupMember, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers)
}() }()
getGroupMemberInfo := func() (string, error) { getGroupMemberInfo := func() (string, error) {
groupMembers, err := relation.GetGroupMemberListByGroupID(groupID) groupMembers, err := relation.GetGroupMemberListByGroupID(groupID)
@ -351,7 +351,7 @@ func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (group
func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) { func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
}() }()
return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID) return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID)
} }
@ -400,7 +400,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends)
}() }()
allFriendInfoStr, err := db.DB.Rc.Fetch(allFriendInfoCache+userID, time.Second*30*60, getAllFriendInfo) allFriendInfoStr, err := db.DB.Rc.Fetch(allFriendInfoCache+userID, time.Second*30*60, getAllFriendInfo)
if err != nil { if err != nil {
@ -412,7 +412,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) { func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID) return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID)
} }
@ -430,7 +430,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs)
}() }()
joinedSuperGroupListStr, err := db.DB.Rc.Fetch(joinedSuperGroupListCache+userID, time.Second*30*60, getJoinedSuperGroupIDList) joinedSuperGroupListStr, err := db.DB.Rc.Fetch(joinedSuperGroupListCache+userID, time.Second*30*60, getJoinedSuperGroupIDList)
if err != nil { if err != nil {
@ -442,7 +442,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) { func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return db.DB.Rc.TagAsDeleted(joinedSuperGroupListCache + userID) return db.DB.Rc.TagAsDeleted(joinedSuperGroupListCache + userID)
} }
@ -470,7 +470,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC
return strconv.Itoa(int(bi.Uint64())), nil return strconv.Itoa(int(bi.Uint64())), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64)
}() }()
hashCodeStr, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash) hashCodeStr, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash)
if err != nil { if err != nil {
@ -482,7 +482,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC
func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) { func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
}() }()
return db.DB.Rc.TagAsDeleted(groupMemberListHashCache + groupID) return db.DB.Rc.TagAsDeleted(groupMemberListHashCache + groupID)
} }
@ -496,7 +496,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e
return strconv.Itoa(int(num)), nil return strconv.Itoa(int(num)), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num)
}() }()
groupMember, err := db.DB.Rc.Fetch(groupMemberNumCache+groupID, time.Second*30*60, getGroupMemberNum) groupMember, err := db.DB.Rc.Fetch(groupMemberNumCache+groupID, time.Second*30*60, getGroupMemberNum)
if err != nil { if err != nil {
@ -507,7 +507,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e
func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) { func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
}() }()
return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID) return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID)
} }
@ -526,7 +526,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs)
}() }()
conversationIDListStr, err := db.DB.Rc.Fetch(conversationIDListCache+userID, time.Second*30*60, getConversationIDList) conversationIDListStr, err := db.DB.Rc.Fetch(conversationIDListCache+userID, time.Second*30*60, getConversationIDList)
err = json.Unmarshal([]byte(conversationIDListStr), &conversationIDs) err = json.Unmarshal([]byte(conversationIDListStr), &conversationIDs)
@ -538,7 +538,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con
func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) { func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
}() }()
return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationIDListCache+userID), "DelUserConversationIDListFromCache err") return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationIDListCache+userID), "DelUserConversationIDListFromCache err")
} }
@ -556,7 +556,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation)
}() }()
conversationStr, err := db.DB.Rc.Fetch(conversationCache+ownerUserID+":"+conversationID, time.Second*30*60, getConversation) conversationStr, err := db.DB.Rc.Fetch(conversationCache+ownerUserID+":"+conversationID, time.Second*30*60, getConversation)
if err != nil { if err != nil {
@ -569,7 +569,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s
func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []relation.Conversation, err error) { func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []relation.Conversation, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations)
}() }()
for _, conversationID := range conversationIDs { for _, conversationID := range conversationIDs {
conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID) conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID)
@ -583,7 +583,7 @@ func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversa
func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []relation.Conversation, err error) { func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []relation.Conversation, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations)
}() }()
IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID) IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID)
if err != nil { if err != nil {
@ -603,7 +603,7 @@ func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conver
func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) { func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID)
}() }()
return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationCache+ownerUserID+":"+conversationID), "DelConversationFromCache err") return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationCache+ownerUserID+":"+conversationID), "DelConversationFromCache err")
} }
@ -621,7 +621,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien
return string(bytes), nil return string(bytes), nil
} }
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType", tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType",
sessionType, "clientMsgID", clientMsgID, "firstModifyTime", firstModifyTime, "extendMsg", extendMsg) sessionType, "clientMsgID", clientMsgID, "firstModifyTime", firstModifyTime, "extendMsg", extendMsg)
}() }()
extendMsgStr, err := db.DB.Rc.Fetch(extendMsgCache+clientMsgID, time.Second*30*60, getExtendMsg) extendMsgStr, err := db.DB.Rc.Fetch(extendMsgCache+clientMsgID, time.Second*30*60, getExtendMsg)
@ -635,7 +635,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien
func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) { func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID)
}() }()
return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err") return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err")
} }

16
pkg/common/db/relation/black.go
Unescape View File

@ -26,35 +26,35 @@ func NewBlack(db *gorm.DB) *Black {
func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) { func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}() }()
return utils.Wrap(b.DB.Create(&blacks).Error, "") return utils.Wrap(b.DB.Create(&blacks).Error, "")
} }
func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) { func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}() }()
return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "") return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "")
} }
func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) { func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
}() }()
return utils.Wrap(b.DB.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "") return utils.Wrap(b.DB.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
} }
func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) { func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
}() }()
return utils.Wrap(b.DB.Updates(&blacks).Error, "") return utils.Wrap(b.DB.Updates(&blacks).Error, "")
} }
func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black, err error) { func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
}() }()
var where [][]interface{} var where [][]interface{}
for _, black := range blacks { for _, black := range blacks {
@ -66,20 +66,20 @@ func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black,
func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (black *Black, err error) { func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (black *Black, err error) {
black = &Black{} black = &Black{}
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black)
}() }()
return black, utils.Wrap(b.DB.Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "") return black, utils.Wrap(b.DB.Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
} }
func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) { func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
}() }()
return blackList, utils.Wrap(GroupMemberDB.Where("owner_user_id = ?", ownerUserID).Find(&blackList).Error, "") return blackList, utils.Wrap(GroupMemberDB.Where("owner_user_id = ?", ownerUserID).Find(&blackList).Error, "")
} }
func InsertInToUserBlackList(ctx context.Context, black Black) (err error) { func InsertInToUserBlackList(ctx context.Context, black Black) (err error) {
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black) defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black)
black.CreateTime = time.Now() black.CreateTime = time.Now()
err = BlackDB.Create(black).Error err = BlackDB.Create(black).Error
return err return err

18
pkg/common/db/relation/friend_model_k.go
Unescape View File

@ -27,14 +27,14 @@ func NewFriend(db *gorm.DB) *Friend {
func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) { func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
return utils.Wrap(f.DB.Create(&friends).Error, "") return utils.Wrap(f.DB.Create(&friends).Error, "")
} }
func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) { func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
}() }()
err = utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "") err = utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
return err return err
@ -42,48 +42,48 @@ func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs s
func (f *Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) { func (f *Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}() }()
return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "") return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
} }
func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) { func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
return utils.Wrap(f.DB.Updates(&friends).Error, "") return utils.Wrap(f.DB.Updates(&friends).Error, "")
} }
func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) { func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark)
}() }()
return utils.Wrap(f.DB.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "") return utils.Wrap(f.DB.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "")
} }
func (f *Friend) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { func (f *Friend) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
}() }()
return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
} }
func (f *Friend) FindFriendUserID(ctx context.Context, friendUserID string) (friends []*Friend, err error) { func (f *Friend) FindFriendUserID(ctx context.Context, friendUserID string) (friends []*Friend, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friendUserID", friendUserID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friendUserID", friendUserID, "friends", friends)
}() }()
return friends, utils.Wrap(f.DB.Where("friend_user_id = ?", friendUserID).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("friend_user_id = ?", friendUserID).Find(&friends).Error, "")
} }
func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) { func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) {
friend = &Friend{} friend = &Friend{}
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend) defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend)
return friend, utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "") return friend, utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
} }
func (f *Friend) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*Friend, err error) { func (f *Friend) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*Friend, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2)
}() }()
return friends, utils.Wrap(f.DB.Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "")
} }

16
pkg/common/db/relation/friend_request_model.go
Unescape View File

@ -31,55 +31,55 @@ func NewFriendRequest(db *gorm.DB) *FriendRequest {
func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (err error) { func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
return utils.Wrap(f.DB.Create(&friends).Error, "") return utils.Wrap(f.DB.Create(&friends).Error, "")
} }
func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) { func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
}() }()
return utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "") return utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
} }
func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) { func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
}() }()
return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "") return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
} }
func (f *FriendRequest) Update(ctx context.Context, friends []*FriendRequest) (err error) { func (f *FriendRequest) Update(ctx context.Context, friends []*FriendRequest) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
}() }()
return utils.Wrap(f.DB.Updates(&friends).Error, "") return utils.Wrap(f.DB.Updates(&friends).Error, "")
} }
func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends []*FriendRequest, err error) { func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends []*FriendRequest, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
}() }()
return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
} }
func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) { func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) {
friend = &FriendRequest{} friend = &FriendRequest{}
defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend) defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend)
return friend, utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "") return friend, utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "")
} }
func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) { func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends)
}() }()
return friends, utils.Wrap(f.DB.Where("to_user_id = ?", toUserID).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("to_user_id = ?", toUserID).Find(&friends).Error, "")
} }
func (f *FriendRequest) FindFromUserID(ctx context.Context, fromUserID string) (friends []*FriendRequest, err error) { func (f *FriendRequest) FindFromUserID(ctx context.Context, fromUserID string) (friends []*FriendRequest, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends) tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends)
}() }()
return friends, utils.Wrap(f.DB.Where("from_user_id = ?", fromUserID).Find(&friends).Error, "") return friends, utils.Wrap(f.DB.Where("from_user_id = ?", fromUserID).Find(&friends).Error, "")
} }

15
pkg/common/db/relation/group_member_model_k.go
Unescape View File

@ -3,6 +3,7 @@ package relation
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/common/tracelog"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"fmt" "fmt"
@ -33,33 +34,33 @@ func NewGroupMemberDB(db *gorm.DB) *GroupMember {
func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember, tx ...*gorm.DB) (err error) { func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Create(&groupMemberList).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Create(&groupMemberList).Error, "")
} }
func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) { func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Delete(groupMembers).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Delete(groupMembers).Error, "")
} }
func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...*gorm.DB) (err error) { func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
} }
func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) { func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }() defer func() { tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
return utils.Wrap(getDBConn(g.DB, tx).Updates(&groupMembers).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Updates(&groupMembers).Error, "")
} }
func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (groupList []*GroupMember, err error) { func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (groupList []*GroupMember, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
}() }()
var where [][]interface{} var where [][]interface{}
for _, groupMember := range groupMembers { for _, groupMember := range groupMembers {
@ -70,7 +71,7 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx
func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) { func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
}() }()
groupMember = &GroupMember{} groupMember = &GroupMember{}
return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "") return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
@ -78,7 +79,7 @@ func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, t
func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) { func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
}() }()
groupMember = &GroupMember{} groupMember = &GroupMember{}
return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "") return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "")

18
pkg/common/db/relation/group_model_k.go
Unescape View File

@ -1,7 +1,7 @@
package relation package relation
import ( import (
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/tracelog"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"gorm.io/gorm" "gorm.io/gorm"
@ -35,35 +35,35 @@ func NewGroupDB(db *gorm.DB) *Group {
func (g *Group) Create(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) { func (g *Group) Create(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Create(&groups).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Create(&groups).Error, "")
} }
func (g *Group) Delete(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (err error) { func (g *Group) Delete(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "")
} }
func (g *Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}, tx ...*gorm.DB) (err error) { func (g *Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Model(g).Updates(args).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Model(g).Updates(args).Error, "")
} }
func (g *Group) Update(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) { func (g *Group) Update(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
}() }()
return utils.Wrap(getDBConn(g.DB, tx).Updates(&groups).Error, "") return utils.Wrap(getDBConn(g.DB, tx).Updates(&groups).Error, "")
} }
func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (groups []*Group, err error) { func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (groups []*Group, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups)
}() }()
return groups, utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Find(&groups).Error, "") return groups, utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
} }
@ -71,11 +71,7 @@ func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (gr
func (g *Group) Take(ctx context.Context, groupID string, tx ...*gorm.DB) (group *Group, err error) { func (g *Group) Take(ctx context.Context, groupID string, tx ...*gorm.DB) (group *Group, err error) {
group = &Group{} group = &Group{}
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
}() }()
return group, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Take(group).Error, "") return group, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Take(group).Error, "")
} }
//func (g *Group) DeleteTx(ctx context.Context, groupIDs []string) error {
// return nil
//}

12
pkg/common/db/relation/group_request_model_k.go
Unescape View File

@ -37,35 +37,35 @@ func (GroupRequest) TableName() string {
func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(GroupRequestDB.Delete(&groupRequests).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Delete(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) { func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
}() }()
return utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Updates(args).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Updates(args).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
}() }()
return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName()) return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) { func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests)
}() }()
var where [][]interface{} var where [][]interface{}
for _, groupMember := range groupRequests { for _, groupMember := range groupRequests {
@ -77,7 +77,7 @@ func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (r
func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) { func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) {
groupRequest = &GroupRequest{} groupRequest = &GroupRequest{}
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest)
}() }()
return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName()) return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
} }

12
pkg/common/db/relation/user_model_k.go
Unescape View File

@ -34,7 +34,7 @@ func NewUserDB(db *gorm.DB) *User {
func (u *User) Create(ctx context.Context, users []*User) (err error) { func (u *User) Create(ctx context.Context, users []*User) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}() }()
err = utils.Wrap(u.DB.Create(&users).Error, "") err = utils.Wrap(u.DB.Create(&users).Error, "")
return err return err
@ -42,21 +42,21 @@ func (u *User) Create(ctx context.Context, users []*User) (err error) {
func (u *User) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) { func (u *User) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args)
}() }()
return utils.Wrap(u.DB.Where("user_id = ?", userID).Updates(args).Error, "") return utils.Wrap(u.DB.Where("user_id = ?", userID).Updates(args).Error, "")
} }
func (u *User) Update(ctx context.Context, users []*User) (err error) { func (u *User) Update(ctx context.Context, users []*User) (err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
}() }()
return utils.Wrap(u.DB.Updates(&users).Error, "") return utils.Wrap(u.DB.Updates(&users).Error, "")
} }
func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err error) { func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users)
}() }()
err = utils.Wrap(u.DB.Where("user_id in (?)", userIDs).Find(&users).Error, "") err = utils.Wrap(u.DB.Where("user_id in (?)", userIDs).Find(&users).Error, "")
return users, err return users, err
@ -65,7 +65,7 @@ func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err e
func (u *User) Take(ctx context.Context, userID string) (user *User, err error) { func (u *User) Take(ctx context.Context, userID string) (user *User, err error) {
user = &User{} user = &User{}
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user)
}() }()
err = utils.Wrap(u.DB.Where("user_id = ?", userID).Take(&user).Error, "") err = utils.Wrap(u.DB.Where("user_id = ?", userID).Take(&user).Error, "")
return user, err return user, err
@ -73,7 +73,7 @@ func (u *User) Take(ctx context.Context, userID string) (user *User, err error)
func (u *User) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*User, err error) { func (u *User) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*User, err error) {
defer func() { defer func() {
trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users) tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
}() }()
err = u.DB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error err = u.DB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
return users, utils.Wrap(err, "") return users, utils.Wrap(err, "")

20
pkg/common/log/logrus.go
Unescape View File

@ -237,8 +237,8 @@ func NewWarn(OperationID string, args ...interface{}) {
} }
func ShowLog(ctx context.Context) { func ShowLog(ctx context.Context) {
t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
OperationID := trace_log.GetOperationID(ctx) OperationID := tracelog.GetOperationID(ctx)
//if ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo).GinCtx != nil { //if ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo).GinCtx != nil {
// ctxLogger.WithFields(logrus.Fields{ // ctxLogger.WithFields(logrus.Fields{
// "OperationID": OperationID, // "OperationID": OperationID,
@ -284,8 +284,8 @@ func ShowLog(ctx context.Context) {
} }
func InfoWithCtx(ctx context.Context, args ...interface{}) { func InfoWithCtx(ctx context.Context, args ...interface{}) {
t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
OperationID := trace_log.GetOperationID(ctx) OperationID := tracelog.GetOperationID(ctx)
for _, v := range *t.Funcs { for _, v := range *t.Funcs {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"OperationID": OperationID, "OperationID": OperationID,
@ -295,8 +295,8 @@ func InfoWithCtx(ctx context.Context, args ...interface{}) {
} }
func DebugWithCtx(ctx context.Context, args ...interface{}) { func DebugWithCtx(ctx context.Context, args ...interface{}) {
t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
OperationID := trace_log.GetOperationID(ctx) OperationID := tracelog.GetOperationID(ctx)
for _, v := range *t.Funcs { for _, v := range *t.Funcs {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"OperationID": OperationID, "OperationID": OperationID,
@ -306,8 +306,8 @@ func DebugWithCtx(ctx context.Context, args ...interface{}) {
} }
func ErrorWithCtx(ctx context.Context, args ...interface{}) { func ErrorWithCtx(ctx context.Context, args ...interface{}) {
t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
OperationID := trace_log.GetOperationID(ctx) OperationID := tracelog.GetOperationID(ctx)
for _, v := range *t.Funcs { for _, v := range *t.Funcs {
if v.Err != nil { if v.Err != nil {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
@ -319,8 +319,8 @@ func ErrorWithCtx(ctx context.Context, args ...interface{}) {
} }
func WarnWithCtx(ctx context.Context, args ...interface{}) { func WarnWithCtx(ctx context.Context, args ...interface{}) {
t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
OperationID := trace_log.GetOperationID(ctx) OperationID := tracelog.GetOperationID(ctx)
for _, v := range *t.Funcs { for _, v := range *t.Funcs {
logger.WithFields(logrus.Fields{ logger.WithFields(logrus.Fields{
"OperationID": OperationID, "OperationID": OperationID,

8
pkg/common/middleware/rpc.go
Unescape View File

@ -37,12 +37,12 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary
if opts := md.Get("opUserID"); len(opts) == 1 { if opts := md.Get("opUserID"); len(opts) == 1 {
opUserID = opts[0] opUserID = opts[0]
} }
ctx = trace_log.NewRpcCtx(ctx, funcName, operationID) ctx = tracelog.NewRpcCtx(ctx, funcName, operationID)
defer log.ShowLog(ctx) defer log.ShowLog(ctx)
trace_log.SetCtxInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req)) tracelog.SetCtxInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req))
resp, err = handler(ctx, req) resp, err = handler(ctx, req)
if err != nil { if err != nil {
trace_log.SetCtxInfo(ctx, funcName, err) tracelog.SetCtxInfo(ctx, funcName, err)
errInfo := constant.ToAPIErrWithErr(err) errInfo := constant.ToAPIErrWithErr(err)
var code codes.Code var code codes.Code
if errInfo.ErrCode == 0 { if errInfo.ErrCode == 0 {
@ -56,7 +56,7 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary
} }
return nil, sta.Err() return nil, sta.Err()
} }
trace_log.SetCtxInfo(ctx, funcName, nil, "rpcResp", rpcString(resp)) tracelog.SetCtxInfo(ctx, funcName, nil, "rpcResp", rpcString(resp))
return return
} }

2
pkg/common/token_verify/jwt_token.go
Unescape View File

@ -162,7 +162,7 @@ func CheckAccess(ctx context.Context, OpUserID string, OwnerUserID string) bool
func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) { func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
opUserID := tools.OpUserID(ctx) opUserID := tools.OpUserID(ctx)
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", opUserID, "ownerUserID", ownerUserID) tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", opUserID, "ownerUserID", ownerUserID)
}() }()
if utils.IsContain(opUserID, config.Config.Manager.AppManagerUid) { if utils.IsContain(opUserID, config.Config.Manager.AppManagerUid) {
return nil return nil

2
pkg/common/trace_log/ctx.go → pkg/common/tracelog/ctx.go
Unescape View File

@ -1,4 +1,4 @@
package trace_log package tracelog
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"

5
pkg/getcdv3/temp.go
Unescape View File

@ -4,6 +4,7 @@ import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/common/tracelog"
"context" "context"
"github.com/OpenIMSDK/getcdv3" "github.com/OpenIMSDK/getcdv3"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -16,10 +17,10 @@ func GetDefaultConn(arg1, arg2, arg3, arg4 string) *grpc.ClientConn {
func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) { func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) {
defer func() { defer func() {
trace_log.SetCtxInfo(ctx, "GetConn", err, "serviceName", serviceName) tracelog.SetCtxInfo(ctx, "GetConn", err, "serviceName", serviceName)
}() }()
conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","),
serviceName, trace_log.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password) serviceName, tracelog.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)
if conn == nil { if conn == nil {
return nil, constant.ErrInternalServer return nil, constant.ErrInternalServer
} }

Write Preview
Loading…
Cancel
Save