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

error

Browse Source
test-errcode
withchao 3 years ago
parent 3fe9ee22fe
commit 4c5613084c
40 changed files with 315 additions and 297 deletions
Show Stats Download Patch File Download Diff File

2
cmd/cmdutils/main.go
Unescape View File

@ -8,7 +8,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
// clear msg by id // clear msg by id

2
cmd/crontask/main.go
Unescape View File

@ -9,7 +9,7 @@ import (
func main() { func main() {
fmt.Println(time.Now(), "start cronTask") fmt.Println(time.Now(), "start cronTask")
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := tools.StartCronTask(); err != nil { if err := tools.StartCronTask(); err != nil {

2
cmd/msggateway/main.go
Unescape View File

@ -11,7 +11,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
log.NewPrivateLog(constant.LogFileName) log.NewPrivateLog(constant.LogFileName)

2
cmd/msgtransfer/main.go
Unescape View File

@ -10,7 +10,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
var wg sync.WaitGroup var wg sync.WaitGroup

2
cmd/rpc/auth/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImAuthPort[0], config.Config.RpcRegisterName.OpenImAuthName, config.Config.Prometheus.AuthPrometheusPort[0], auth.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImAuthPort[0], config.Config.RpcRegisterName.OpenImAuthName, config.Config.Prometheus.AuthPrometheusPort[0], auth.Start); err != nil {

2
cmd/rpc/conversation/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImConversationPort[0], config.Config.RpcRegisterName.OpenImConversationName, config.Config.Prometheus.ConversationPrometheusPort[0], conversation.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImConversationPort[0], config.Config.RpcRegisterName.OpenImConversationName, config.Config.Prometheus.ConversationPrometheusPort[0], conversation.Start); err != nil {

2
cmd/rpc/friend/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImFriendPort[0], config.Config.RpcRegisterName.OpenImFriendName, config.Config.Prometheus.FriendPrometheusPort[0], friend.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImFriendPort[0], config.Config.RpcRegisterName.OpenImFriendName, config.Config.Prometheus.FriendPrometheusPort[0], friend.Start); err != nil {

2
cmd/rpc/group/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImGroupPort[0], config.Config.RpcRegisterName.OpenImGroupName, config.Config.Prometheus.GroupPrometheusPort[0], group.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImGroupPort[0], config.Config.RpcRegisterName.OpenImGroupName, config.Config.Prometheus.GroupPrometheusPort[0], group.Start); err != nil {

2
cmd/rpc/msg/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImMessagePort[0], config.Config.RpcRegisterName.OpenImMsgName, config.Config.Prometheus.AuthPrometheusPort[0], msg.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImMessagePort[0], config.Config.RpcRegisterName.OpenImMsgName, config.Config.Prometheus.AuthPrometheusPort[0], msg.Start); err != nil {

2
cmd/rpc/third/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImThirdPort[0], config.Config.RpcRegisterName.OpenImThirdName, config.Config.Prometheus.ThirdPrometheusPort[0], third.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImThirdPort[0], config.Config.RpcRegisterName.OpenImThirdName, config.Config.Prometheus.ThirdPrometheusPort[0], third.Start); err != nil {

2
cmd/rpc/user/main.go
Unescape View File

@ -7,7 +7,7 @@ import (
) )
func main() { func main() {
if err := config.InitConfig(); err != nil { if err := config.InitConfig(""); err != nil {
panic(err.Error()) panic(err.Error())
} }
if err := startrpc.Start(config.Config.RpcPort.OpenImUserPort[0], config.Config.RpcRegisterName.OpenImUserName, config.Config.Prometheus.UserPrometheusPort[0], user.Start); err != nil { if err := startrpc.Start(config.Config.RpcPort.OpenImUserPort[0], config.Config.RpcRegisterName.OpenImUserName, config.Config.Prometheus.UserPrometheusPort[0], user.Start); err != nil {

8
internal/api/a2r/api2rpc.go
Unescape View File

@ -2,7 +2,7 @@ package a2r
import ( import (
"OpenIM/internal/apiresp" "OpenIM/internal/apiresp"
"OpenIM/pkg/common/constant" "OpenIM/pkg/errs"
"context" "context"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -15,18 +15,18 @@ func Call[A, B, C any](
) { ) {
var req A var req A
if err := c.BindJSON(&req); err != nil { if err := c.BindJSON(&req); err != nil {
apiresp.GinError(c, constant.ErrArgs.Wrap(err.Error())) // 参数错误 apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error())) // 参数错误
return return
} }
if check, ok := any(&req).(interface{ Check() error }); ok { if check, ok := any(&req).(interface{ Check() error }); ok {
if err := check.Check(); err != nil { if err := check.Check(); err != nil {
apiresp.GinError(c, constant.ErrArgs.Wrap(err.Error())) // 参数校验失败 apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error())) // 参数校验失败
return return
} }
} }
cli, err := client() cli, err := client()
if err != nil { if err != nil {
apiresp.GinError(c, constant.ErrInternalServer.Wrap(err.Error())) // 获取RPC连接失败 apiresp.GinError(c, errs.ErrInternalServer.Wrap(err.Error())) // 获取RPC连接失败
return return
} }
data, err := rpc(cli, c, &req) data, err := rpc(cli, c, &req)

11
internal/api/msg.go
Unescape View File

@ -7,6 +7,7 @@ import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/log" "OpenIM/pkg/common/log"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/msg" "OpenIM/pkg/proto/msg"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -192,22 +193,22 @@ func (o *Msg) ManagementSendMsg(c *gin.Context) {
return return
} }
if err := mapstructure.WeakDecode(params.Content, &data); err != nil { if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
apiresp.GinError(c, constant.ErrData) apiresp.GinError(c, errs.ErrData)
return return
} else if err := o.validate.Struct(data); err != nil { } else if err := o.validate.Struct(data); err != nil {
apiresp.GinError(c, constant.ErrData) apiresp.GinError(c, errs.ErrData)
return return
} }
log.NewInfo(params.OperationID, data, params) log.NewInfo(params.OperationID, data, params)
switch params.SessionType { switch params.SessionType {
case constant.SingleChatType: case constant.SingleChatType:
if len(params.RecvID) == 0 { if len(params.RecvID) == 0 {
apiresp.GinError(c, constant.ErrData) apiresp.GinError(c, errs.ErrData)
return return
} }
case constant.GroupChatType, constant.SuperGroupChatType: case constant.GroupChatType, constant.SuperGroupChatType:
if len(params.GroupID) == 0 { if len(params.GroupID) == 0 {
apiresp.GinError(c, constant.ErrData) apiresp.GinError(c, errs.ErrData)
return return
} }
} }
@ -215,7 +216,7 @@ func (o *Msg) ManagementSendMsg(c *gin.Context) {
pbData := newUserSendMsgReq(&params) pbData := newUserSendMsgReq(&params)
conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImMsgName) conn, err := o.zk.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
if err != nil { if err != nil {
apiresp.GinError(c, constant.ErrInternalServer) apiresp.GinError(c, errs.ErrInternalServer)
return return
} }
client := msg.NewMsgClient(conn) client := msg.NewMsgClient(conn)

3
internal/common/check/friend.go
Unescape View File

@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
discoveryRegistry "OpenIM/pkg/discoveryregistry" discoveryRegistry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/friend" "OpenIM/pkg/proto/friend"
sdkws "OpenIM/pkg/proto/sdkws" sdkws "OpenIM/pkg/proto/sdkws"
"context" "context"
@ -67,7 +68,7 @@ func (f *FriendChecker) GetAllPageFriends(ctx context.Context, ownerUserID strin
if tmp.Total == int32(len(resp)) { if tmp.Total == int32(len(resp)) {
return resp, nil return resp, nil
} }
return nil, constant.ErrData.Wrap("The total number of results and expectations are different, but result is nil") return nil, errs.ErrData.Wrap("The total number of results and expectations are different, but result is nil")
} }
resp = append(resp, tmp.FriendsInfo...) resp = append(resp, tmp.FriendsInfo...)
page++ page++

5
internal/common/check/group.go
Unescape View File

@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
discoveryRegistry "OpenIM/pkg/discoveryregistry" discoveryRegistry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/group" "OpenIM/pkg/proto/group"
sdkws "OpenIM/pkg/proto/sdkws" sdkws "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -41,7 +42,7 @@ func (g *GroupChecker) GetGroupInfos(ctx context.Context, groupIDs []string, com
if ids := utils.Single(groupIDs, utils.Slice(resp.GroupInfos, func(e *sdkws.GroupInfo) string { if ids := utils.Single(groupIDs, utils.Slice(resp.GroupInfos, func(e *sdkws.GroupInfo) string {
return e.GroupID return e.GroupID
})); len(ids) > 0 { })); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ",")) return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
} }
} }
return resp.GroupInfos, nil return resp.GroupInfos, nil
@ -81,7 +82,7 @@ func (g *GroupChecker) GetGroupMemberInfos(ctx context.Context, groupID string,
if ids := utils.Single(userIDs, utils.Slice(resp.Members, func(e *sdkws.GroupMemberFullInfo) string { if ids := utils.Single(userIDs, utils.Slice(resp.Members, func(e *sdkws.GroupMemberFullInfo) string {
return e.UserID return e.UserID
})); len(ids) > 0 { })); len(ids) > 0 {
return nil, constant.ErrNotInGroupYet.Wrap(strings.Join(ids, ",")) return nil, errs.ErrNotInGroupYet.Wrap(strings.Join(ids, ","))
} }
} }
return resp.Members, nil return resp.Members, nil

4
internal/common/check/user.go
Unescape View File

@ -2,8 +2,8 @@ package check
import ( import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/discoveryregistry" "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/proto/user" "OpenIM/pkg/proto/user"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -41,7 +41,7 @@ func (u *UserCheck) GetUsersInfos(ctx context.Context, userIDs []string, complet
if ids := utils.Single(userIDs, utils.Slice(resp.UsersInfo, func(e *sdkws.UserInfo) string { if ids := utils.Single(userIDs, utils.Slice(resp.UsersInfo, func(e *sdkws.UserInfo) string {
return e.UserID return e.UserID
})); len(ids) > 0 { })); len(ids) > 0 {
return nil, constant.ErrUserIDNotFound.Wrap(strings.Join(ids, ",")) return nil, errs.ErrUserIDNotFound.Wrap(strings.Join(ids, ","))
} }
} }
return resp.UsersInfo, nil return resp.UsersInfo, nil

2
internal/msggateway/batch_push.go
Unescape View File

@ -1,14 +1,12 @@
package msggateway package msggateway
import ( import (
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/log" "OpenIM/pkg/common/log"
pbChat "OpenIM/pkg/proto/msg" pbChat "OpenIM/pkg/proto/msg"
sdkws "OpenIM/pkg/proto/sdkws" sdkws "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
"google.golang.org/grpc" "google.golang.org/grpc"
"strings"
) )
var MaxPullMsgNum = 100 var MaxPullMsgNum = 100

42
internal/msggateway/new/http_error.go
Unescape View File

@ -1,7 +1,7 @@
package new package new
import ( import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/errs"
"errors" "errors"
"net/http" "net/http"
) )
@ -10,35 +10,35 @@ func httpError(ctx *UserConnContext, err error) {
code := http.StatusUnauthorized code := http.StatusUnauthorized
ctx.SetHeader("Sec-Websocket-Version", "13") ctx.SetHeader("Sec-Websocket-Version", "13")
ctx.SetHeader("ws_err_msg", err.Error()) ctx.SetHeader("ws_err_msg", err.Error())
if errors.Is(err, constant.ErrTokenExpired) { if errors.Is(err, errs.ErrTokenExpired) {
code = int(constant.ErrTokenExpired.ErrCode) code = errs.ErrTokenExpired.Code()
} }
if errors.Is(err, constant.ErrTokenInvalid) { if errors.Is(err, errs.ErrTokenInvalid) {
code = int(constant.ErrTokenInvalid.ErrCode) code = errs.ErrTokenInvalid.Code()
} }
if errors.Is(err, constant.ErrTokenMalformed) { if errors.Is(err, errs.ErrTokenMalformed) {
code = int(constant.ErrTokenMalformed.ErrCode) code = errs.ErrTokenMalformed.Code()
} }
if errors.Is(err, constant.ErrTokenNotValidYet) { if errors.Is(err, errs.ErrTokenNotValidYet) {
code = int(constant.ErrTokenNotValidYet.ErrCode) code = errs.ErrTokenNotValidYet.Code()
} }
if errors.Is(err, constant.ErrTokenUnknown) { if errors.Is(err, errs.ErrTokenUnknown) {
code = int(constant.ErrTokenUnknown.ErrCode) code = errs.ErrTokenUnknown.Code()
} }
if errors.Is(err, constant.ErrTokenKicked) { if errors.Is(err, errs.ErrTokenKicked) {
code = int(constant.ErrTokenKicked.ErrCode) code = errs.ErrTokenKicked.Code()
} }
if errors.Is(err, constant.ErrTokenDifferentPlatformID) { if errors.Is(err, errs.ErrTokenDifferentPlatformID) {
code = int(constant.ErrTokenDifferentPlatformID.ErrCode) code = errs.ErrTokenDifferentPlatformID.Code()
} }
if errors.Is(err, constant.ErrTokenDifferentUserID) { if errors.Is(err, errs.ErrTokenDifferentUserID) {
code = int(constant.ErrTokenDifferentUserID.ErrCode) code = errs.ErrTokenDifferentUserID.Code()
} }
if errors.Is(err, constant.ErrConnOverMaxNumLimit) { if errors.Is(err, errs.ErrConnOverMaxNumLimit) {
code = int(constant.ErrConnOverMaxNumLimit.ErrCode) code = errs.ErrConnOverMaxNumLimit.Code()
} }
if errors.Is(err, constant.ErrConnArgsErr) { if errors.Is(err, errs.ErrConnArgsErr) {
code = int(constant.ErrConnArgsErr.ErrCode) code = errs.ErrConnArgsErr.Code()
} }
ctx.ErrReturn(err.Error(), code) ctx.ErrReturn(err.Error(), code)
} }

9
internal/msggateway/new/n_ws_server.go
Unescape View File

@ -3,6 +3,7 @@ package new
import ( import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/errs"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"errors" "errors"
"fmt" "fmt"
@ -131,7 +132,7 @@ func (ws *WsServer) unregisterClient(client *Client) {
func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) { func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
context := newContext(w, r) context := newContext(w, r)
if ws.onlineUserConnNum >= ws.wsMaxConnNum { if ws.onlineUserConnNum >= ws.wsMaxConnNum {
httpError(context, constant.ErrConnOverMaxNumLimit) httpError(context, errs.ErrConnOverMaxNumLimit)
return return
} }
var ( var (
@ -145,17 +146,17 @@ func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
token, exists = context.Query(TOKEN) token, exists = context.Query(TOKEN)
if !exists { if !exists {
httpError(context, constant.ErrConnArgsErr) httpError(context, errs.ErrConnArgsErr)
return return
} }
userID, exists = context.Query(WS_USERID) userID, exists = context.Query(WS_USERID)
if !exists { if !exists {
httpError(context, constant.ErrConnArgsErr) httpError(context, errs.ErrConnArgsErr)
return return
} }
platformID, exists = context.Query(PLATFORM_ID) platformID, exists = context.Query(PLATFORM_ID)
if !exists { if !exists {
httpError(context, constant.ErrConnArgsErr) httpError(context, errs.ErrConnArgsErr)
return return
} }
err := tokenverify.WsVerifyToken(token, userID, platformID) err := tokenverify.WsVerifyToken(token, userID, platformID)

2
internal/msggateway/relay_rpc_server.go
Unescape View File

@ -143,7 +143,7 @@ func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *msggateway.GetU
log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String()) log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
if !tokenverify.IsManagerUserID(req.OpUserID) { if !tokenverify.IsManagerUserID(req.OpUserID) {
log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID) log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
return &msggateway.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil return &msggateway.GetUsersOnlineStatusResp{ErrCode: errs.ErrAccess.ErrCode, ErrMsg: errs.ErrAccess.ErrMsg}, nil
} }
var resp msggateway.GetUsersOnlineStatusResp var resp msggateway.GetUsersOnlineStatusResp
for _, userID := range req.UserIDList { for _, userID := range req.UserIDList {

71
internal/msggateway/ws_server.go
Unescape View File

@ -6,6 +6,7 @@ import (
"OpenIM/pkg/common/log" "OpenIM/pkg/common/log"
"OpenIM/pkg/common/prome" "OpenIM/pkg/common/prome"
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/msggateway" "OpenIM/pkg/proto/msggateway"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"bytes" "bytes"
@ -303,8 +304,8 @@ func (ws *WServer) MultiTerminalLoginChecker(uid string, platformID int, newConn
func (ws *WServer) sendKickMsg(oldConn *UserConn) { func (ws *WServer) sendKickMsg(oldConn *UserConn) {
mReply := Resp{ mReply := Resp{
ReqIdentifier: constant.WSKickOnlineMsg, ReqIdentifier: constant.WSKickOnlineMsg,
ErrCode: constant.ErrTokenInvalid.ErrCode, ErrCode: int32(errs.ErrTokenInvalid.Code()),
ErrMsg: constant.ErrTokenInvalid.ErrMsg, ErrMsg: errs.ErrTokenInvalid.Msg(),
} }
var b bytes.Buffer var b bytes.Buffer
enc := gob.NewEncoder(&b) enc := gob.NewEncoder(&b)
@ -443,47 +444,47 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operation
query := r.URL.Query() query := r.URL.Query()
if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 { if len(query["token"]) != 0 && len(query["sendID"]) != 0 && len(query["platformID"]) != 0 {
if ok, err, msg := tokenverify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok { if ok, err, msg := tokenverify.WsVerifyToken(query["token"][0], query["sendID"][0], query["platformID"][0], operationID); !ok {
if errors.Is(err, constant.ErrTokenExpired) { if errors.Is(err, errs.ErrTokenExpired) {
status = int(constant.ErrTokenExpired.ErrCode) status = int(errs.ErrTokenExpired.ErrCode)
} }
if errors.Is(err, constant.ErrTokenInvalid) { if errors.Is(err, errs.ErrTokenInvalid) {
status = int(constant.ErrTokenInvalid.ErrCode) status = int(errs.ErrTokenInvalid.ErrCode)
} }
if errors.Is(err, constant.ErrTokenMalformed) { if errors.Is(err, errs.ErrTokenMalformed) {
status = int(constant.ErrTokenMalformed.ErrCode) status = int(errs.ErrTokenMalformed.ErrCode)
} }
if errors.Is(err, constant.ErrTokenNotValidYet) { if errors.Is(err, errs.ErrTokenNotValidYet) {
status = int(constant.ErrTokenNotValidYet.ErrCode) status = int(errs.ErrTokenNotValidYet.ErrCode)
} }
if errors.Is(err, constant.ErrTokenUnknown) { if errors.Is(err, errs.ErrTokenUnknown) {
status = int(constant.ErrTokenUnknown.ErrCode) status = int(errs.ErrTokenUnknown.ErrCode)
} }
if errors.Is(err, constant.ErrTokenKicked) { if errors.Is(err, errs.ErrTokenKicked) {
status = int(constant.ErrTokenKicked.ErrCode) status = int(errs.ErrTokenKicked.ErrCode)
} }
if errors.Is(err, constant.ErrTokenDifferentPlatformID) { if errors.Is(err, errs.ErrTokenDifferentPlatformID) {
status = int(constant.ErrTokenDifferentPlatformID.ErrCode) status = int(errs.ErrTokenDifferentPlatformID.ErrCode)
} }
if errors.Is(err, constant.ErrTokenDifferentUserID) { if errors.Is(err, errs.ErrTokenDifferentUserID) {
status = int(constant.ErrTokenDifferentUserID.ErrCode) status = int(errs.ErrTokenDifferentUserID.ErrCode)
} }
//switch errors.Cause(err) { //switch errors.Cause(err) {
//case constant.ErrTokenExpired: //case errs.ErrTokenExpired:
// status = int(constant.ErrTokenExpired.ErrCode) // status = int(errs.ErrTokenExpired.ErrCode)
//case constant.ErrTokenInvalid: //case errs.ErrTokenInvalid:
// status = int(constant.ErrTokenInvalid.ErrCode) // status = int(errs.ErrTokenInvalid.ErrCode)
//case constant.ErrTokenMalformed: //case errs.ErrTokenMalformed:
// status = int(constant.ErrTokenMalformed.ErrCode) // status = int(errs.ErrTokenMalformed.ErrCode)
//case constant.ErrTokenNotValidYet: //case errs.ErrTokenNotValidYet:
// status = int(constant.ErrTokenNotValidYet.ErrCode) // status = int(errs.ErrTokenNotValidYet.ErrCode)
//case constant.ErrTokenUnknown: //case errs.ErrTokenUnknown:
// status = int(constant.ErrTokenUnknown.ErrCode) // status = int(errs.ErrTokenUnknown.ErrCode)
//case constant.ErrTokenKicked: //case errs.ErrTokenKicked:
// status = int(constant.ErrTokenKicked.ErrCode) // status = int(errs.ErrTokenKicked.ErrCode)
//case constant.ErrTokenDifferentPlatformID: //case errs.ErrTokenDifferentPlatformID:
// status = int(constant.ErrTokenDifferentPlatformID.ErrCode) // status = int(errs.ErrTokenDifferentPlatformID.ErrCode)
//case constant.ErrTokenDifferentUserID: //case errs.ErrTokenDifferentUserID:
// status = int(constant.ErrTokenDifferentUserID.ErrCode) // status = int(errs.ErrTokenDifferentUserID.ErrCode)
//} //}
log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error(), "status: ", status) log.Error(operationID, "Token verify failed ", "query ", query, msg, err.Error(), "status: ", status)
@ -502,7 +503,7 @@ func (ws *WServer) headerCheck(w http.ResponseWriter, r *http.Request, operation
return true, compression return true, compression
} }
} else { } else {
status = int(constant.ErrArgs.ErrCode) status = int(errs.ErrArgs.ErrCode)
log.Error(operationID, "Args err ", "query ", query) log.Error(operationID, "Args err ", "query ", query)
w.Header().Set("Sec-Websocket-Version", "13") w.Header().Set("Sec-Websocket-Version", "13")
errMsg := "args err, need token, sendID, platformID" errMsg := "args err, need token, sendID, platformID"

5
internal/push/push_to_client.go
Unescape View File

@ -20,6 +20,7 @@ import (
"OpenIM/pkg/common/prome" "OpenIM/pkg/common/prome"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
"OpenIM/pkg/discoveryregistry" "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/msggateway" "OpenIM/pkg/proto/msggateway"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -67,7 +68,7 @@ func (p *Pusher) MsgToUser(ctx context.Context, userID string, msg *sdkws.MsgDat
var userIDs = []string{userID} var userIDs = []string{userID}
log.Debug(operationID, "Get msg from msg_transfer And push msg", msg.String(), userID) log.Debug(operationID, "Get msg from msg_transfer And push msg", msg.String(), userID)
// callback // callback
if err := callbackOnlinePush(ctx, userIDs, msg); err != nil && err != constant.ErrCallbackContinue { if err := callbackOnlinePush(ctx, userIDs, msg); err != nil && err != errs.ErrCallbackContinue {
return err return err
} }
// push // push
@ -110,7 +111,7 @@ func (p *Pusher) MsgToSuperGroupUser(ctx context.Context, groupID string, msg *s
operationID := tracelog.GetOperationID(ctx) operationID := tracelog.GetOperationID(ctx)
log.Debug(operationID, "Get super group msg from msg_transfer And push msg", msg.String(), groupID) log.Debug(operationID, "Get super group msg from msg_transfer And push msg", msg.String(), groupID)
var pushToUserIDs []string var pushToUserIDs []string
if err := callbackBeforeSuperGroupOnlinePush(ctx, groupID, msg, &pushToUserIDs); err != nil && err != constant.ErrCallbackContinue { if err := callbackBeforeSuperGroupOnlinePush(ctx, groupID, msg, &pushToUserIDs); err != nil && err != errs.ErrCallbackContinue {
return err return err
} }
if len(pushToUserIDs) == 0 { if len(pushToUserIDs) == 0 {

11
internal/rpc/auth/auth.go
Unescape View File

@ -10,6 +10,7 @@ import (
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
discoveryRegistry "OpenIM/pkg/discoveryregistry" discoveryRegistry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbAuth "OpenIM/pkg/proto/auth" pbAuth "OpenIM/pkg/proto/auth"
"OpenIM/pkg/proto/msggateway" "OpenIM/pkg/proto/msggateway"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -60,19 +61,19 @@ func (s *authServer) parseToken(ctx context.Context, tokensString string) (claim
return nil, err return nil, err
} }
if len(m) == 0 { if len(m) == 0 {
return nil, constant.ErrTokenNotExist.Wrap() return nil, errs.ErrTokenNotExist.Wrap()
} }
if v, ok := m[tokensString]; ok { if v, ok := m[tokensString]; ok {
switch v { switch v {
case constant.NormalToken: case constant.NormalToken:
return claims, nil return claims, nil
case constant.KickedToken: case constant.KickedToken:
return nil, constant.ErrTokenKicked.Wrap() return nil, errs.ErrTokenKicked.Wrap()
default: default:
return nil, utils.Wrap(constant.ErrTokenUnknown, "") return nil, utils.Wrap(errs.ErrTokenUnknown, "")
} }
} }
return nil, constant.ErrTokenNotExist.Wrap() return nil, errs.ErrTokenNotExist.Wrap()
} }
func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) { func (s *authServer) ParseToken(ctx context.Context, req *pbAuth.ParseTokenReq) (resp *pbAuth.ParseTokenResp, err error) {
@ -110,5 +111,5 @@ func (s *authServer) forceKickOff(ctx context.Context, userID string, platformID
_, err := client.KickUserOffline(ctx, kickReq) _, err := client.KickUserOffline(ctx, kickReq)
return utils.Wrap(err, "") return utils.Wrap(err, "")
} }
return constant.ErrInternalServer.Wrap() return errs.ErrInternalServer.Wrap()
} }

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

@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
registry "OpenIM/pkg/discoveryregistry" registry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbfriend "OpenIM/pkg/proto/friend" pbfriend "OpenIM/pkg/proto/friend"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
@ -50,11 +51,11 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil { if err := tokenverify.CheckAccessV3(ctx, req.FromUserID); err != nil {
return nil, err return nil, err
} }
if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err := CallbackBeforeAddFriend(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
if req.ToUserID == req.FromUserID { if req.ToUserID == req.FromUserID {
return nil, constant.ErrCanNotAddYourself.Wrap() return nil, errs.ErrCanNotAddYourself.Wrap()
} }
if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil { if _, err := s.userCheck.GetUsersInfoMap(ctx, []string{req.ToUserID, req.FromUserID}, true); err != nil {
return nil, err return nil, err
@ -64,7 +65,7 @@ func (s *friendServer) ApplyToAddFriend(ctx context.Context, req *pbfriend.Apply
return nil, err return nil, err
} }
if in1 && in2 { if in1 && in2 {
return nil, constant.ErrRelationshipAlready.Wrap() return nil, errs.ErrRelationshipAlready.Wrap()
} }
if err = s.FriendDatabase.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil { if err = s.FriendDatabase.AddFriendRequest(ctx, req.FromUserID, req.ToUserID, req.ReqMsg, req.Ex); err != nil {
return nil, err return nil, err
@ -84,10 +85,10 @@ func (s *friendServer) ImportFriends(ctx context.Context, req *pbfriend.ImportFr
} }
if utils.Contain(req.OwnerUserID, req.FriendUserIDs...) { if utils.Contain(req.OwnerUserID, req.FriendUserIDs...) {
return nil, constant.ErrCanNotAddYourself.Wrap() return nil, errs.ErrCanNotAddYourself.Wrap()
} }
if utils.Duplicate(req.FriendUserIDs) { if utils.Duplicate(req.FriendUserIDs) {
return nil, constant.ErrArgs.Wrap("friend userID repeated") return nil, errs.ErrArgs.Wrap("friend userID repeated")
} }
if err := s.FriendDatabase.BecomeFriends(ctx, req.OwnerUserID, req.FriendUserIDs, constant.BecomeFriendByImport, tracelog.GetOpUserID(ctx)); err != nil { if err := s.FriendDatabase.BecomeFriends(ctx, req.OwnerUserID, req.FriendUserIDs, constant.BecomeFriendByImport, tracelog.GetOpUserID(ctx)); err != nil {
@ -119,7 +120,7 @@ func (s *friendServer) RespondFriendApply(ctx context.Context, req *pbfriend.Res
s.notification.FriendApplicationRefusedNotification(ctx, req) s.notification.FriendApplicationRefusedNotification(ctx, req)
return resp, nil return resp, nil
} }
return nil, constant.ErrArgs.Wrap("req.HandleResult != -1/1") return nil, errs.ErrArgs.Wrap("req.HandleResult != -1/1")
} }
// ok // ok
@ -162,7 +163,7 @@ func (s *friendServer) GetDesignatedFriends(ctx context.Context, req *pbfriend.G
resp = &pbfriend.GetDesignatedFriendsResp{} resp = &pbfriend.GetDesignatedFriendsResp{}
if utils.Duplicate(req.FriendUserIDs) { if utils.Duplicate(req.FriendUserIDs) {
return nil, constant.ErrArgs.Wrap("friend userID repeated") return nil, errs.ErrArgs.Wrap("friend userID repeated")
} }
friends, err := s.FriendDatabase.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs) friends, err := s.FriendDatabase.FindFriendsWithError(ctx, req.OwnerUserID, req.FriendUserIDs)
if err != nil { if err != nil {

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

@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
"OpenIM/pkg/discoveryregistry" "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
pbConversation "OpenIM/pkg/proto/conversation" pbConversation "OpenIM/pkg/proto/conversation"
pbGroup "OpenIM/pkg/proto/group" pbGroup "OpenIM/pkg/proto/group"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
@ -65,7 +66,7 @@ func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error
return err return err
} }
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) { if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return constant.ErrNoPermission.Wrap("no group owner or admin") return errs.ErrNoPermission.Wrap("no group owner or admin")
} }
} }
return nil return nil
@ -92,7 +93,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
if *groupID != "" { if *groupID != "" {
_, err := s.GroupDatabase.TakeGroup(ctx, *groupID) _, err := s.GroupDatabase.TakeGroup(ctx, *groupID)
if err == nil { if err == nil {
return constant.ErrGroupIDExisted.Wrap("group id existed " + *groupID) return errs.ErrGroupIDExisted.Wrap("group id existed " + *groupID)
} else if s.IsNotFound(err) { } else if s.IsNotFound(err) {
return nil return nil
} else { } else {
@ -114,7 +115,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
return err return err
} }
} }
return constant.ErrData.Wrap("group id gen error") return errs.ErrData.Wrap("group id gen error")
} }
func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) { func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (*pbGroup.CreateGroupResp, error) {
@ -123,17 +124,17 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
return nil, err return nil, err
} }
if req.OwnerUserID == "" { if req.OwnerUserID == "" {
return nil, constant.ErrArgs.Wrap("no group owner") return nil, errs.ErrArgs.Wrap("no group owner")
} }
userIDs := append(append(req.InitMembers, req.AdminUserIDs...), req.OwnerUserID) userIDs := append(append(req.InitMembers, req.AdminUserIDs...), req.OwnerUserID)
if utils.Duplicate(userIDs) { if utils.Duplicate(userIDs) {
return nil, constant.ErrArgs.Wrap("group member repeated") return nil, errs.ErrArgs.Wrap("group member repeated")
} }
userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true) userMap, err := s.UserCheck.GetUsersInfoMap(ctx, userIDs, true)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err := CallbackBeforeCreateGroup(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
var groupMembers []*relationTb.GroupMemberModel var groupMembers []*relationTb.GroupMemberModel
@ -149,7 +150,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
groupMember.OperatorUserID = tracelog.GetOpUserID(ctx) groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
groupMember.JoinSource = constant.JoinByInvitation groupMember.JoinSource = constant.JoinByInvitation
groupMember.InviterUserID = tracelog.GetOpUserID(ctx) groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue { if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return err return err
} }
groupMembers = append(groupMembers, groupMember) groupMembers = append(groupMembers, groupMember)
@ -233,17 +234,17 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) { func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
resp := &pbGroup.InviteUserToGroupResp{} resp := &pbGroup.InviteUserToGroupResp{}
if len(req.InvitedUserIDs) == 0 { if len(req.InvitedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("user empty") return nil, errs.ErrArgs.Wrap("user empty")
} }
if utils.Duplicate(req.InvitedUserIDs) { if utils.Duplicate(req.InvitedUserIDs) {
return nil, constant.ErrArgs.Wrap("userID duplicate") return nil, errs.ErrArgs.Wrap("userID duplicate")
} }
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID) group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrDismissedAlready.Wrap() return nil, errs.ErrDismissedAlready.Wrap()
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{group.GroupID}, nil, nil) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{group.GroupID}, nil, nil)
if err != nil { if err != nil {
@ -253,7 +254,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
return e.UserID return e.UserID
}) })
if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 { if ids := utils.Single(req.InvitedUserIDs, utils.Keys(memberMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user in group " + strings.Join(ids, ",")) return nil, errs.ErrArgs.Wrap("user in group " + strings.Join(ids, ","))
} }
userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true) userMap, err := s.UserCheck.GetUsersInfoMap(ctx, req.InvitedUserIDs, true)
if err != nil { if err != nil {
@ -264,7 +265,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
opUserID := tracelog.GetOpUserID(ctx) opUserID := tracelog.GetOpUserID(ctx)
member, ok := memberMap[opUserID] member, ok := memberMap[opUserID]
if !ok { if !ok {
return nil, constant.ErrNoPermission.Wrap("not in group") return nil, errs.ErrNoPermission.Wrap("not in group")
} }
if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) { if !(member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin) {
var requests []*relationTb.GroupRequestModel var requests []*relationTb.GroupRequestModel
@ -309,7 +310,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
member.OperatorUserID = opUserID member.OperatorUserID = opUserID
member.InviterUserID = opUserID member.InviterUserID = opUserID
member.JoinSource = constant.JoinByInvitation member.JoinSource = constant.JoinByInvitation
if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue { if err := CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
groupMembers = append(groupMembers, member) groupMembers = append(groupMembers, member)
@ -329,7 +330,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbGroup.GetGro
return nil, err return nil, err
} }
if group.GroupType == constant.SuperGroup { if group.GroupType == constant.SuperGroup {
return nil, constant.ErrArgs.Wrap("unsupported super group") return nil, errs.ErrArgs.Wrap("unsupported super group")
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, nil) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, nil)
if err != nil { if err != nil {
@ -379,14 +380,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
return nil, err return nil, err
} }
if len(req.KickedUserIDs) == 0 { if len(req.KickedUserIDs) == 0 {
return nil, constant.ErrArgs.Wrap("KickedUserIDs empty") return nil, errs.ErrArgs.Wrap("KickedUserIDs empty")
} }
if utils.IsDuplicateStringSlice(req.KickedUserIDs) { if utils.IsDuplicateStringSlice(req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("KickedUserIDs duplicate") return nil, errs.ErrArgs.Wrap("KickedUserIDs duplicate")
} }
opUserID := tracelog.GetOpUserID(ctx) opUserID := tracelog.GetOpUserID(ctx)
if utils.IsContain(opUserID, req.KickedUserIDs) { if utils.IsContain(opUserID, req.KickedUserIDs) {
return nil, constant.ErrArgs.Wrap("opUserID in KickedUserIDs") return nil, errs.ErrArgs.Wrap("opUserID in KickedUserIDs")
} }
if group.GroupType == constant.SuperGroup { if group.GroupType == constant.SuperGroup {
if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, req.KickedUserIDs); err != nil { if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, req.KickedUserIDs); err != nil {
@ -408,13 +409,13 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
} }
for _, userID := range req.KickedUserIDs { for _, userID := range req.KickedUserIDs {
if _, ok := memberMap[userID]; !ok { if _, ok := memberMap[userID]; !ok {
return nil, constant.ErrUserIDNotFound.Wrap(userID) return nil, errs.ErrUserIDNotFound.Wrap(userID)
} }
} }
if !tokenverify.IsAppManagerUid(ctx) { if !tokenverify.IsAppManagerUid(ctx) {
member := memberMap[opUserID] member := memberMap[opUserID]
if member == nil { if member == nil {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID)) return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("opUserID %s no in group", opUserID))
} }
switch member.RoleLevel { switch member.RoleLevel {
case constant.GroupOwner: case constant.GroupOwner:
@ -424,11 +425,11 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
continue continue
} }
if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin { if member.RoleLevel == constant.GroupOwner || member.RoleLevel == constant.GroupAdmin {
return nil, constant.ErrNoPermission.Wrap("userID:" + member.UserID) return nil, errs.ErrNoPermission.Wrap("userID:" + member.UserID)
} }
} }
default: default:
return nil, constant.ErrNoPermission.Wrap("opUserID is OrdinaryUser") return nil, errs.ErrNoPermission.Wrap("opUserID is OrdinaryUser")
} }
} }
if err := s.GroupDatabase.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil { if err := s.GroupDatabase.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
@ -442,10 +443,10 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) { func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbGroup.GetGroupMembersInfoReq) (*pbGroup.GetGroupMembersInfoResp, error) {
resp := &pbGroup.GetGroupMembersInfoResp{} resp := &pbGroup.GetGroupMembersInfoResp{}
if len(req.Members) == 0 { if len(req.Members) == 0 {
return nil, constant.ErrArgs.Wrap("members empty") return nil, errs.ErrArgs.Wrap("members empty")
} }
if req.GroupID == "" { if req.GroupID == "" {
return nil, constant.ErrArgs.Wrap("groupID empty") return nil, errs.ErrArgs.Wrap("groupID empty")
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, req.Members, nil) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, req.Members, nil)
if err != nil { if err != nil {
@ -498,7 +499,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 { if ids := utils.Single(utils.Keys(groupMap), groupIDs); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ",")) return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
} }
groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs) groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil { if err != nil {
@ -520,7 +521,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) { func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsInfoReq) (*pbGroup.GetGroupsInfoResp, error) {
resp := &pbGroup.GetGroupsInfoResp{} resp := &pbGroup.GetGroupsInfoResp{}
if len(req.GroupIDs) == 0 { if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupID is empty") return nil, errs.ErrArgs.Wrap("groupID is empty")
} }
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs) groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil { if err != nil {
@ -546,7 +547,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) { func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
resp := &pbGroup.GroupApplicationResponseResp{} resp := &pbGroup.GroupApplicationResponseResp{}
if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) { if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
return nil, constant.ErrArgs.Wrap("HandleResult unknown") return nil, errs.ErrArgs.Wrap("HandleResult unknown")
} }
if !tokenverify.IsAppManagerUid(ctx) { if !tokenverify.IsAppManagerUid(ctx) {
groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID) groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID)
@ -554,7 +555,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err return nil, err
} }
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) { if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return nil, constant.ErrNoPermission.Wrap("no group owner or admin") return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
} }
} }
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID) group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
@ -566,7 +567,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
return nil, err return nil, err
} }
if groupRequest.HandleResult != 0 { if groupRequest.HandleResult != 0 {
return nil, constant.ErrArgs.Wrap("group request already processed") return nil, errs.ErrArgs.Wrap("group request already processed")
} }
var join bool var join bool
if _, err = s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil { if _, err = s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.FromUserID); err == nil {
@ -592,7 +593,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
OperatorUserID: tracelog.GetOpUserID(ctx), OperatorUserID: tracelog.GetOpUserID(ctx),
Ex: groupRequest.Ex, Ex: groupRequest.Ex,
} }
if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != constant.ErrCallbackContinue { if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
} }
@ -620,11 +621,11 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
return nil, err return nil, err
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrDismissedAlready.Wrap() return nil, errs.ErrDismissedAlready.Wrap()
} }
if group.NeedVerification == constant.Directly { if group.NeedVerification == constant.Directly {
if group.GroupType == constant.SuperGroup { if group.GroupType == constant.SuperGroup {
return nil, constant.ErrGroupTypeNotSupport.Wrap() return nil, errs.ErrGroupTypeNotSupport.Wrap()
} }
user, err := s.UserCheck.GetUserInfo(ctx, tracelog.GetOpUserID(ctx)) user, err := s.UserCheck.GetUserInfo(ctx, tracelog.GetOpUserID(ctx))
if err != nil { if err != nil {
@ -636,7 +637,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
groupMember.OperatorUserID = tracelog.GetOpUserID(ctx) groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
groupMember.JoinSource = constant.JoinByInvitation groupMember.JoinSource = constant.JoinByInvitation
groupMember.InviterUserID = tracelog.GetOpUserID(ctx) groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != constant.ErrCallbackContinue { if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
if err := s.GroupDatabase.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil { if err := s.GroupDatabase.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
@ -688,7 +689,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return nil, err return nil, err
} }
if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) { if !(groupMember.RoleLevel == constant.GroupOwner || groupMember.RoleLevel == constant.GroupAdmin) {
return nil, constant.ErrNoPermission.Wrap("no group owner or admin") return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
} }
} }
group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupInfoForSet.GroupID) group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupInfoForSet.GroupID)
@ -696,7 +697,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
return nil, err return nil, err
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, utils.Wrap(constant.ErrDismissedAlready, "") return nil, utils.Wrap(errs.ErrDismissedAlready, "")
} }
userIDs, err := s.GroupDatabase.FindGroupMemberUserID(ctx, group.GroupID) userIDs, err := s.GroupDatabase.FindGroupMemberUserID(ctx, group.GroupID)
if err != nil { if err != nil {
@ -739,10 +740,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
return nil, err return nil, err
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, utils.Wrap(constant.ErrDismissedAlready, "") return nil, utils.Wrap(errs.ErrDismissedAlready, "")
} }
if req.OldOwnerUserID == req.NewOwnerUserID { if req.OldOwnerUserID == req.NewOwnerUserID {
return nil, constant.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID") return nil, errs.ErrArgs.Wrap("OldOwnerUserID == NewOwnerUserID")
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{req.OldOwnerUserID, req.NewOwnerUserID}, nil) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, []string{req.OldOwnerUserID, req.NewOwnerUserID}, nil)
if err != nil { if err != nil {
@ -750,11 +751,11 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
} }
memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string { return e.UserID }) memberMap := utils.SliceToMap(members, func(e *relationTb.GroupMemberModel) string { return e.UserID })
if ids := utils.Single([]string{req.OldOwnerUserID, req.NewOwnerUserID}, utils.Keys(memberMap)); len(ids) > 0 { if ids := utils.Single([]string{req.OldOwnerUserID, req.NewOwnerUserID}, utils.Keys(memberMap)); len(ids) > 0 {
return nil, constant.ErrArgs.Wrap("user not in group " + strings.Join(ids, ",")) return nil, errs.ErrArgs.Wrap("user not in group " + strings.Join(ids, ","))
} }
newOwner := memberMap[req.NewOwnerUserID] newOwner := memberMap[req.NewOwnerUserID]
if newOwner == nil { if newOwner == nil {
return nil, constant.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID) return nil, errs.ErrArgs.Wrap("NewOwnerUser not in group " + req.NewOwnerUserID)
} }
oldOwner := memberMap[req.OldOwnerUserID] oldOwner := memberMap[req.OldOwnerUserID]
if tokenverify.IsAppManagerUid(ctx) { if tokenverify.IsAppManagerUid(ctx) {
@ -766,10 +767,10 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
} }
} else { } else {
if oldOwner == nil { if oldOwner == nil {
return nil, constant.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID) return nil, errs.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
} }
if oldOwner.GroupID != tracelog.GetOpUserID(ctx) { if oldOwner.GroupID != tracelog.GetOpUserID(ctx) {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx))) return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
} }
} }
if err := s.GroupDatabase.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil { if err := s.GroupDatabase.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
@ -805,7 +806,7 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(groupIDs, utils.Keys(ownerMemberMap)); len(ids) > 0 { if ids := utils.Single(groupIDs, utils.Keys(ownerMemberMap)); len(ids) > 0 {
return nil, constant.ErrDB.Wrap("group not owner " + strings.Join(ids, ",")) return nil, errs.ErrDatabase.Wrap("group not owner " + strings.Join(ids, ","))
} }
groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs) groupMemberNumMap, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil { if err != nil {
@ -865,7 +866,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 { if ids := utils.Single(groupIDs, utils.Keys(groupMap)); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(strings.Join(ids, ",")) return nil, errs.ErrGroupIDNotFound.Wrap(strings.Join(ids, ","))
} }
owners, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner}) owners, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, nil, []int32{constant.GroupOwner})
if err != nil { if err != nil {
@ -875,7 +876,7 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 { if ids := utils.Single(groupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap("group no owner", strings.Join(ids, ",")) return nil, errs.ErrData.Wrap("group no owner", strings.Join(ids, ","))
} }
groupMemberNum, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs) groupMemberNum, err := s.GroupDatabase.MapGroupMemberNum(ctx, groupIDs)
if err != nil { if err != nil {
@ -897,7 +898,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
return nil, err return nil, err
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
return nil, constant.ErrArgs.Wrap("group status is dismissed") return nil, errs.ErrArgs.Wrap("group status is dismissed")
} }
if err := s.GroupDatabase.DismissGroup(ctx, req.GroupID); err != nil { if err := s.GroupDatabase.DismissGroup(ctx, req.GroupID); err != nil {
return nil, err return nil, err
@ -924,7 +925,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
return nil, err return nil, err
} }
if opMember.RoleLevel <= member.RoleLevel { if opMember.RoleLevel <= member.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel)) return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
} }
} }
data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds))) data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds)))
@ -947,7 +948,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
return nil, err return nil, err
} }
if opMember.RoleLevel <= member.RoleLevel { if opMember.RoleLevel <= member.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel)) return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("self RoleLevel %d target %d", opMember.RoleLevel, member.RoleLevel))
} }
} }
data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0)) data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0))
@ -985,7 +986,7 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) { func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (*pbGroup.SetGroupMemberInfoResp, error) {
resp := &pbGroup.SetGroupMemberInfoResp{} resp := &pbGroup.SetGroupMemberInfoResp{}
if len(req.Members) == 0 { if len(req.Members) == 0 {
return nil, constant.ErrArgs.Wrap("members empty") return nil, errs.ErrArgs.Wrap("members empty")
} }
duplicateMap := make(map[[2]string]struct{}) duplicateMap := make(map[[2]string]struct{})
userIDMap := make(map[string]struct{}) userIDMap := make(map[string]struct{})
@ -993,7 +994,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
for _, member := range req.Members { for _, member := range req.Members {
key := [...]string{member.GroupID, member.UserID} key := [...]string{member.GroupID, member.UserID}
if _, ok := duplicateMap[key]; ok { if _, ok := duplicateMap[key]; ok {
return nil, constant.ErrArgs.Wrap("group user duplicate") return nil, errs.ErrArgs.Wrap("group user duplicate")
} }
duplicateMap[key] = struct{}{} duplicateMap[key] = struct{}{}
userIDMap[member.UserID] = struct{}{} userIDMap[member.UserID] = struct{}{}
@ -1009,7 +1010,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
delete(duplicateMap, [...]string{member.GroupID, member.UserID}) delete(duplicateMap, [...]string{member.GroupID, member.UserID})
} }
if len(duplicateMap) > 0 { if len(duplicateMap) > 0 {
return nil, constant.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string { return nil, errs.ErrArgs.Wrap("group not found" + strings.Join(utils.Slice(utils.Keys(duplicateMap), func(e [2]string) string {
return fmt.Sprintf("[group: %s user: %s]", e[0], e[1]) return fmt.Sprintf("[group: %s user: %s]", e[0], e[1])
}), ",")) }), ","))
} }
@ -1024,10 +1025,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
} }
opMember, ok := memberMap[[...]string{member.GroupID, member.UserID}] opMember, ok := memberMap[[...]string{member.GroupID, member.UserID}]
if !ok { if !ok {
return nil, constant.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID)) return nil, errs.ErrArgs.Wrap(fmt.Sprintf("user %s not in group %s", opUserID, member.GroupID))
} }
if member.RoleLevel >= opMember.RoleLevel { if member.RoleLevel >= opMember.RoleLevel {
return nil, constant.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel)) return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("group %s : %s RoleLevel %d >= %s RoleLevel %d", member.GroupID, member.UserID, member.RoleLevel, opMember.UserID, opMember.RoleLevel))
} }
} }
} }
@ -1036,7 +1037,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
continue continue
} }
if memberMap[[...]string{member.GroupID, member.UserID}].RoleLevel == constant.GroupOwner { if memberMap[[...]string{member.GroupID, member.UserID}].RoleLevel == constant.GroupOwner {
return nil, constant.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID)) return nil, errs.ErrArgs.Wrap(fmt.Sprintf("group %s user %s is owner", member.GroupID, member.UserID))
} }
} }
for i := 0; i < len(req.Members); i++ { for i := 0; i < len(req.Members); i++ {
@ -1063,10 +1064,10 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) { func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.GetGroupAbstractInfoReq) (*pbGroup.GetGroupAbstractInfoResp, error) {
resp := &pbGroup.GetGroupAbstractInfoResp{} resp := &pbGroup.GetGroupAbstractInfoResp{}
if len(req.GroupIDs) == 0 { if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty") return nil, errs.ErrArgs.Wrap("groupIDs empty")
} }
if utils.Duplicate(req.GroupIDs) { if utils.Duplicate(req.GroupIDs) {
return nil, constant.ErrArgs.Wrap("groupIDs duplicate") return nil, errs.ErrArgs.Wrap("groupIDs duplicate")
} }
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs) groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil { if err != nil {
@ -1075,14 +1076,14 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
if ids := utils.Single(req.GroupIDs, utils.Slice(groups, func(group *relationTb.GroupModel) string { if ids := utils.Single(req.GroupIDs, utils.Slice(groups, func(group *relationTb.GroupModel) string {
return group.GroupID return group.GroupID
})); len(ids) > 0 { })); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ",")) return nil, errs.ErrGroupIDNotFound.Wrap("not found group " + strings.Join(ids, ","))
} }
groupUserMap, err := s.GroupDatabase.MapGroupMemberUserID(ctx, req.GroupIDs) groupUserMap, err := s.GroupDatabase.MapGroupMemberUserID(ctx, req.GroupIDs)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if ids := utils.Single(req.GroupIDs, utils.Keys(groupUserMap)); len(ids) > 0 { if ids := utils.Single(req.GroupIDs, utils.Keys(groupUserMap)); len(ids) > 0 {
return nil, constant.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ","))) return nil, errs.ErrGroupIDNotFound.Wrap(fmt.Sprintf("group %s not found member", strings.Join(ids, ",")))
} }
resp.GroupAbstractInfos = utils.Slice(groups, func(group *relationTb.GroupModel) *pbGroup.GroupAbstractInfo { resp.GroupAbstractInfos = utils.Slice(groups, func(group *relationTb.GroupModel) *pbGroup.GroupAbstractInfo {
users := groupUserMap[group.GroupID] users := groupUserMap[group.GroupID]
@ -1094,7 +1095,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.GetUserInGroupMembersReq) (*pbGroup.GetUserInGroupMembersResp, error) { func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbGroup.GetUserInGroupMembersReq) (*pbGroup.GetUserInGroupMembersResp, error) {
resp := &pbGroup.GetUserInGroupMembersResp{} resp := &pbGroup.GetUserInGroupMembersResp{}
if len(req.GroupIDs) == 0 { if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty") return nil, errs.ErrArgs.Wrap("groupIDs empty")
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.UserID}, req.GroupIDs, nil) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.UserID}, req.GroupIDs, nil)
if err != nil { if err != nil {
@ -1127,7 +1128,7 @@ func (s *groupServer) GetGroupMemberUserIDs(ctx context.Context, req *pbGroup.Ge
func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) { func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbGroup.GetGroupMemberRoleLevelReq) (*pbGroup.GetGroupMemberRoleLevelResp, error) {
resp := &pbGroup.GetGroupMemberRoleLevelResp{} resp := &pbGroup.GetGroupMemberRoleLevelResp{}
if len(req.RoleLevels) == 0 { if len(req.RoleLevels) == 0 {
return nil, constant.ErrArgs.Wrap("RoleLevels empty") return nil, errs.ErrArgs.Wrap("RoleLevels empty")
} }
members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels) members, err := s.GroupDatabase.FindGroupMember(ctx, []string{req.GroupID}, nil, req.RoleLevels)
if err != nil { if err != nil {

7
internal/rpc/group/super_group.go
Unescape View File

@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/db/table/relation" "OpenIM/pkg/common/db/table/relation"
"OpenIM/pkg/common/db/table/unrelation" "OpenIM/pkg/common/db/table/unrelation"
"OpenIM/pkg/errs"
pbGroup "OpenIM/pkg/proto/group" pbGroup "OpenIM/pkg/proto/group"
sdkws "OpenIM/pkg/proto/sdkws" sdkws "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -29,7 +30,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(ownerMap)); len(ids) > 0 { if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(ownerMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ","))) return nil, errs.ErrData.Wrap(fmt.Sprintf("super group %s not owner", strings.Join(ids, ",")))
} }
groups, err := s.GroupDatabase.FindGroup(ctx, joinSuperGroup.GroupIDs) groups, err := s.GroupDatabase.FindGroup(ctx, joinSuperGroup.GroupIDs)
if err != nil { if err != nil {
@ -39,7 +40,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
return e.GroupID return e.GroupID
}) })
if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(groupMap)); len(ids) > 0 { if ids := utils.Single(joinSuperGroup.GroupIDs, utils.Keys(groupMap)); len(ids) > 0 {
return nil, constant.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ","))) return nil, errs.ErrData.Wrap(fmt.Sprintf("super group info %s not found", strings.Join(ids, ",")))
} }
superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, joinSuperGroup.GroupIDs) superGroupMembers, err := s.GroupDatabase.FindSuperGroup(ctx, joinSuperGroup.GroupIDs)
if err != nil { if err != nil {
@ -57,7 +58,7 @@ func (s *groupServer) GetJoinedSuperGroupList(ctx context.Context, req *pbGroup.
func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) { func (s *groupServer) GetSuperGroupsInfo(ctx context.Context, req *pbGroup.GetSuperGroupsInfoReq) (resp *pbGroup.GetSuperGroupsInfoResp, err error) {
resp = &pbGroup.GetSuperGroupsInfoResp{} resp = &pbGroup.GetSuperGroupsInfoResp{}
if len(req.GroupIDs) == 0 { if len(req.GroupIDs) == 0 {
return nil, constant.ErrArgs.Wrap("groupIDs empty") return nil, errs.ErrArgs.Wrap("groupIDs empty")
} }
groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs) groups, err := s.GroupDatabase.FindGroup(ctx, req.GroupIDs)
if err != nil { if err != nil {

23
internal/rpc/msg/send_msg.go
Unescape View File

@ -3,6 +3,7 @@ package msg
import ( import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/msg" "OpenIM/pkg/proto/msg"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -80,7 +81,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err return nil, err
} }
if black { if black {
return nil, constant.ErrBlockedByPeer.Wrap() return nil, errs.ErrBlockedByPeer.Wrap()
} }
if *config.Config.MessageVerify.FriendVerify { if *config.Config.MessageVerify.FriendVerify {
friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID) friend, err := m.friend.IsFriend(ctx, data.MsgData.SendID, data.MsgData.RecvID)
@ -88,7 +89,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err return nil, err
} }
if !friend { if !friend {
return nil, constant.ErrNotPeersFriend.Wrap() return nil, errs.ErrNotPeersFriend.Wrap()
} }
return nil, nil return nil, nil
} }
@ -108,14 +109,14 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil return userIDList, nil
} }
if !utils.IsContain(data.MsgData.SendID, userIDList) { if !utils.IsContain(data.MsgData.SendID, userIDList) {
return nil, constant.ErrNotInGroupYet.Wrap() return nil, errs.ErrNotInGroupYet.Wrap()
} }
isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID) isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if isMute { if isMute {
return nil, constant.ErrMutedInGroup.Wrap() return nil, errs.ErrMutedInGroup.Wrap()
} }
isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID) isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@ -127,7 +128,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
} }
if isMute { if isMute {
return nil, constant.ErrMutedGroup.Wrap() return nil, errs.ErrMutedGroup.Wrap()
} }
return userIDList, nil return userIDList, nil
case constant.SuperGroupChatType: case constant.SuperGroupChatType:
@ -139,7 +140,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
revokeMessage := new(MessageRevoked) revokeMessage := new(MessageRevoked)
err := utils.JsonStringToStruct(string(data.MsgData.Content), revokeMessage) err := utils.JsonStringToStruct(string(data.MsgData.Content), revokeMessage)
if err != nil { if err != nil {
return nil, constant.ErrArgs.Wrap() return nil, errs.ErrArgs.Wrap()
} }
if revokeMessage.RevokerID != revokeMessage.SourceMessageSendID { if revokeMessage.RevokerID != revokeMessage.SourceMessageSendID {
@ -153,7 +154,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
revokeMessage.SourceMessageSendID = resp[0].SendID revokeMessage.SourceMessageSendID = resp[0].SendID
data.MsgData.Content = []byte(utils.StructToJsonString(revokeMessage)) data.MsgData.Content = []byte(utils.StructToJsonString(revokeMessage))
} else { } else {
return nil, constant.ErrData.Wrap("MsgData") return nil, errs.ErrData.Wrap("MsgData")
} }
} }
} }
@ -172,7 +173,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil return userIDList, nil
} else { } else {
if !utils.IsContain(data.MsgData.SendID, userIDList) { if !utils.IsContain(data.MsgData.SendID, userIDList) {
return nil, constant.ErrNotInGroupYet.Wrap() return nil, errs.ErrNotInGroupYet.Wrap()
} }
} }
isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID) isMute, err := m.userIsMuteAndIsAdminInGroup(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@ -180,7 +181,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return nil, err return nil, err
} }
if isMute { if isMute {
return nil, constant.ErrMutedInGroup.Wrap() return nil, errs.ErrMutedInGroup.Wrap()
} }
isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID) isMute, isAdmin, err := m.groupIsMuted(ctx, data.MsgData.GroupID, data.MsgData.SendID)
@ -191,7 +192,7 @@ func (m *msgServer) messageVerification(ctx context.Context, data *msg.SendMsgRe
return userIDList, nil return userIDList, nil
} }
if isMute { if isMute {
return nil, constant.ErrMutedGroup.Wrap() return nil, errs.ErrMutedGroup.Wrap()
} }
return userIDList, nil return userIDList, nil
@ -328,7 +329,7 @@ func (m *msgServer) sendMsgToGroupOptimization(ctx context.Context, list []strin
} }
if isSend { if isSend {
if v == "" || groupPB.MsgData.SendID == "" { if v == "" || groupPB.MsgData.SendID == "" {
return constant.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty") return errs.ErrArgs.Wrap("userID or groupPB.MsgData.SendID is empty")
} }
err := m.MsgDatabase.MsgToMQ(ctx, v, &msgToMQGroup) err := m.MsgDatabase.MsgToMQ(ctx, v, &msgToMQGroup)
if err != nil { if err != nil {

23
internal/rpc/msg/send_pull.go
Unescape View File

@ -3,6 +3,7 @@ package msg
import ( import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
promePkg "OpenIM/pkg/common/prome" promePkg "OpenIM/pkg/common/prome"
"OpenIM/pkg/errs"
pbConversation "OpenIM/pkg/proto/conversation" pbConversation "OpenIM/pkg/proto/conversation"
"OpenIM/pkg/proto/msg" "OpenIM/pkg/proto/msg"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
@ -16,7 +17,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
resp = &msg.SendMsgResp{} resp = &msg.SendMsgResp{}
promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter) promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
// callback // callback
if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
@ -30,7 +31,7 @@ func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgR
return nil, err return nil, err
} }
// callback // callback
if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err = CallbackAfterSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
@ -62,7 +63,7 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq
func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) { func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter) promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
_, err = m.messageVerification(ctx, req) _, err = m.messageVerification(ctx, req)
@ -77,17 +78,17 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq)
if isSend { if isSend {
err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle) err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.RecvID, &msgToMQSingle)
if err != nil { if err != nil {
return nil, constant.ErrInternalServer.Wrap("insert to mq") return nil, errs.ErrInternalServer.Wrap("insert to mq")
} }
} }
if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself if msgToMQSingle.MsgData.SendID != msgToMQSingle.MsgData.RecvID { //Filter messages sent to yourself
err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle) err = m.MsgDatabase.MsgToMQ(ctx, req.MsgData.SendID, &msgToMQSingle)
if err != nil { if err != nil {
return nil, constant.ErrInternalServer.Wrap("insert to mq") return nil, errs.ErrInternalServer.Wrap("insert to mq")
} }
} }
err = CallbackAfterSendSingleMsg(ctx, req) err = CallbackAfterSendSingleMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue { if err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
promePkg.Inc(promePkg.SingleChatMsgProcessSuccessCounter) promePkg.Inc(promePkg.SingleChatMsgProcessSuccessCounter)
@ -103,7 +104,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
// callback // callback
promePkg.Inc(promePkg.GroupChatMsgRecvSuccessCounter) promePkg.Inc(promePkg.GroupChatMsgRecvSuccessCounter)
err = CallbackBeforeSendGroupMsg(ctx, req) err = CallbackBeforeSendGroupMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue { if err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
@ -168,7 +169,7 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
// callback // callback
err = CallbackAfterSendGroupMsg(ctx, req) err = CallbackAfterSendGroupMsg(ctx, req)
if err != nil && err != constant.ErrCallbackContinue { if err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
@ -235,10 +236,10 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
resp = &msg.SendMsgResp{} resp = &msg.SendMsgResp{}
flag := isMessageHasReadEnabled(req.MsgData) flag := isMessageHasReadEnabled(req.MsgData)
if !flag { if !flag {
return nil, constant.ErrMessageHasReadDisable.Wrap() return nil, errs.ErrMessageHasReadDisable.Wrap()
} }
m.encapsulateMsgData(req.MsgData) m.encapsulateMsgData(req.MsgData)
if err := CallbackMsgModify(ctx, req); err != nil && err != constant.ErrCallbackContinue { if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
return nil, err return nil, err
} }
switch req.MsgData.SessionType { switch req.MsgData.SessionType {
@ -251,7 +252,7 @@ func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg
case constant.SuperGroupChatType: case constant.SuperGroupChatType:
return m.sendMsgSuperGroupChat(ctx, req) return m.sendMsgSuperGroupChat(ctx, req)
default: default:
return nil, constant.ErrArgs.Wrap("unknown sessionType") return nil, errs.ErrArgs.Wrap("unknown sessionType")
} }
} }

9
internal/rpc/user/user.go
Unescape View File

@ -12,6 +12,7 @@ import (
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
registry "OpenIM/pkg/discoveryregistry" registry "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/sdkws" "OpenIM/pkg/proto/sdkws"
pbuser "OpenIM/pkg/proto/user" pbuser "OpenIM/pkg/proto/user"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
@ -38,7 +39,7 @@ func Start(client registry.SvcDiscoveryRegistry, server *grpc.Server) error {
} }
users := make([]*tablerelation.UserModel, 0) users := make([]*tablerelation.UserModel, 0)
if len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname) { if len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname) {
return constant.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)") return errs.ErrConfig.Wrap("len(config.Config.Manager.AppManagerUid) != len(config.Config.Manager.Nickname)")
} }
for k, v := range config.Config.Manager.AppManagerUid { for k, v := range config.Config.Manager.AppManagerUid {
users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k]}) users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.Config.Manager.Nickname[k]})
@ -114,7 +115,7 @@ func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.Se
func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) { func (s *userServer) AccountCheck(ctx context.Context, req *pbuser.AccountCheckReq) (resp *pbuser.AccountCheckResp, err error) {
resp = &pbuser.AccountCheckResp{} resp = &pbuser.AccountCheckResp{}
if utils.Duplicate(req.CheckUserIDs) { if utils.Duplicate(req.CheckUserIDs) {
return nil, constant.ErrArgs.Wrap("userID repeated") return nil, errs.ErrArgs.Wrap("userID repeated")
} }
err = tokenverify.CheckAdmin(ctx) err = tokenverify.CheckAdmin(ctx)
if err != nil { if err != nil {
@ -156,7 +157,7 @@ func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPagi
func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) { func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterReq) (resp *pbuser.UserRegisterResp, err error) {
resp = &pbuser.UserRegisterResp{} resp = &pbuser.UserRegisterResp{}
if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) { if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) {
return nil, constant.ErrArgs.Wrap("userID repeated") return nil, errs.ErrArgs.Wrap("userID repeated")
} }
userIDs := make([]string, 0) userIDs := make([]string, 0)
for _, v := range req.Users { for _, v := range req.Users {
@ -167,7 +168,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
return nil, err return nil, err
} }
if exist { if exist {
return nil, constant.ErrRegisteredAlready.Wrap("userID registered already") return nil, errs.ErrRegisteredAlready.Wrap("userID registered already")
} }
users, err := (*convert.PBUser)(nil).PB2DB(req.Users) users, err := (*convert.PBUser)(nil).PB2DB(req.Users)
if err != nil { if err != nil {

6
pkg/callbackstruct/common.go
Unescape View File

@ -2,6 +2,7 @@ package callbackstruct
import ( import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/errs"
"fmt" "fmt"
) )
@ -45,10 +46,7 @@ type CommonCallbackResp struct {
func (c CommonCallbackResp) Parse() error { func (c CommonCallbackResp) Parse() error {
if c.ActionCode != constant.NoError || c.ErrCode != constant.NoError { if c.ActionCode != constant.NoError || c.ErrCode != constant.NoError {
newErr := constant.ErrCallback return errs.NewCodeError(int(c.ErrCode), "Callback").Wrap(fmt.Sprintf("callback response error actionCode is %d, errCode is %d, errMsg is %s", c.ActionCode, c.ErrCode, c.ErrMsg))
newErr.ErrCode = c.ErrCode
newErr.DetailErrMsg = fmt.Sprintf("callback response error actionCode is %d, errCode is %d, errMsg is %s", c.ActionCode, c.ErrCode, c.ErrMsg)
return newErr.Wrap()
} }
return nil return nil
} }

67
pkg/common/constant/error_info.go
Unescape View File

@ -1,11 +1,7 @@
package constant package constant
import ( import (
"OpenIM/pkg/utils"
"encoding/json"
"fmt"
"github.com/pkg/errors" "github.com/pkg/errors"
"gorm.io/gorm"
"strings" "strings"
) )
@ -58,35 +54,36 @@ func toDetail(err error, info *ErrInfo) *ErrInfo {
} }
func ToAPIErrWithErr(err error) *ErrInfo { func ToAPIErrWithErr(err error) *ErrInfo {
unwrap := utils.Unwrap(err) return &ErrInfo{}
if unwrap == gorm.ErrRecordNotFound { //unwrap := utils.Unwrap(err)
return &ErrInfo{ //if unwrap == gorm.ErrRecordNotFound {
ErrCode: ErrRecordNotFound.Code(), // return &ErrInfo{
ErrMsg: ErrRecordNotFound.Msg(), // ErrCode: ErrRecordNotFound.Code(),
DetailErrMsg: fmt.Sprintf("%+v", err), // ErrMsg: ErrRecordNotFound.Msg(),
} // DetailErrMsg: fmt.Sprintf("%+v", err),
} // }
if errInfo, ok := unwrap.(*ErrInfo); ok { //}
return &ErrInfo{ //if errInfo, ok := unwrap.(*ErrInfo); ok {
ErrCode: errInfo.Code(), // return &ErrInfo{
ErrMsg: errInfo.Msg(), // ErrCode: errInfo.Code(),
DetailErrMsg: fmt.Sprintf("%+v", err), // ErrMsg: errInfo.Msg(),
} // DetailErrMsg: fmt.Sprintf("%+v", err),
} // }
//}
errComm := errors.New("") //
var marshalErr *json.MarshalerError //errComm := errors.New("")
errInfo := &ErrInfo{} //var marshalErr *json.MarshalerError
switch { //errInfo := &ErrInfo{}
case errors.As(err, &errComm): //switch {
if errors.Is(err, gorm.ErrRecordNotFound) { //case errors.As(err, &errComm):
return toDetail(err, ErrRecordNotFound) // if errors.Is(err, gorm.ErrRecordNotFound) {
} // return toDetail(err, ErrRecordNotFound)
return toDetail(err, ErrData) // }
case errors.As(err, &marshalErr): // return toDetail(err, ErrData)
return toDetail(err, ErrData) //case errors.As(err, &marshalErr):
case errors.As(err, &errInfo): // return toDetail(err, ErrData)
return toDetail(err, errInfo) //case errors.As(err, &errInfo):
} // return toDetail(err, errInfo)
return toDetail(err, ErrDefaultOther) //}
//return toDetail(err, ErrDefaultOther)
} }

3
pkg/common/db/controller/friend.go
Unescape View File

@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/db/table/relation" "OpenIM/pkg/common/db/table/relation"
"OpenIM/pkg/common/db/tx" "OpenIM/pkg/common/db/tx"
"OpenIM/pkg/errs"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
"errors" "errors"
@ -235,7 +236,7 @@ func (f *friendDatabase) FindFriendsWithError(ctx context.Context, ownerUserID s
return return
} }
if len(friends) != len(friendUserIDs) { if len(friends) != len(friendUserIDs) {
err = constant.ErrRecordNotFound.Wrap() err = errs.ErrRecordNotFound.Wrap()
} }
return return
} }

5
pkg/common/db/controller/user.go
Unescape View File

@ -3,6 +3,7 @@ package controller
import ( import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/db/table/relation" "OpenIM/pkg/common/db/table/relation"
"OpenIM/pkg/errs"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
) )
@ -60,7 +61,7 @@ func (u *userDatabase) FindWithError(ctx context.Context, userIDs []string) (use
return return
} }
if len(users) != len(userIDs) { if len(users) != len(userIDs) {
err = constant.ErrRecordNotFound.Wrap() err = errs.ErrRecordNotFound.Wrap()
} }
return return
} }
@ -114,7 +115,7 @@ func (u *userDatabase) GetAllUserID(ctx context.Context) (userIDs []string, err
if total == int64(len(userIDs)) { if total == int64(len(userIDs)) {
return userIDs, nil return userIDs, nil
} }
return nil, constant.ErrData.Wrap("The total number of results and expectations are different, but result is nil") return nil, errs.ErrData.Wrap("The total number of results and expectations are different, but result is nil")
} }
userIDs = append(userIDs, tmp...) userIDs = append(userIDs, tmp...)
pageNumber++ pageNumber++

4
pkg/common/db/localcache/group.go
Unescape View File

@ -2,8 +2,8 @@ package localcache
import ( import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/discoveryregistry" "OpenIM/pkg/discoveryregistry"
"OpenIM/pkg/errs"
"OpenIM/pkg/proto/group" "OpenIM/pkg/proto/group"
"context" "context"
"sync" "sync"
@ -46,7 +46,7 @@ func (g *GroupLocalCache) GetGroupMemberIDs(ctx context.Context, groupID string)
return nil, err return nil, err
} }
if len(resp.GroupAbstractInfos) < 0 { if len(resp.GroupAbstractInfos) < 0 {
return nil, constant.ErrGroupIDNotFound return nil, errs.ErrGroupIDNotFound
} }
localHashInfo, ok := g.cache[groupID] localHashInfo, ok := g.cache[groupID]
if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash { if ok && localHashInfo.memberListHash == resp.GroupAbstractInfos[0].GroupMemberListHash {

5
pkg/common/http/http_client.go
Unescape View File

@ -10,6 +10,7 @@ import (
"OpenIM/pkg/callbackstruct" "OpenIM/pkg/callbackstruct"
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/errs"
"bytes" "bytes"
"encoding/json" "encoding/json"
"io/ioutil" "io/ioutil"
@ -76,13 +77,13 @@ func callBackPostReturn(url, command string, input interface{}, output callbacks
b, err := Post(url, nil, input, callbackConfig.CallbackTimeOut) b, err := Post(url, nil, input, callbackConfig.CallbackTimeOut)
if err != nil { if err != nil {
if callbackConfig.CallbackFailedContinue != nil && *callbackConfig.CallbackFailedContinue { if callbackConfig.CallbackFailedContinue != nil && *callbackConfig.CallbackFailedContinue {
return constant.ErrCallbackContinue return errs.ErrCallbackContinue
} }
return constant.NewErrNetwork(err) return constant.NewErrNetwork(err)
} }
if err = json.Unmarshal(b, output); err != nil { if err = json.Unmarshal(b, output); err != nil {
if callbackConfig.CallbackFailedContinue != nil && *callbackConfig.CallbackFailedContinue { if callbackConfig.CallbackFailedContinue != nil && *callbackConfig.CallbackFailedContinue {
return constant.ErrCallbackContinue return errs.ErrCallbackContinue
} }
return constant.NewErrData(err) return constant.NewErrData(err)
} }

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

@ -4,6 +4,7 @@ import (
"OpenIM/pkg/common/constant" "OpenIM/pkg/common/constant"
"OpenIM/pkg/common/log" "OpenIM/pkg/common/log"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
"OpenIM/pkg/errs"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
"fmt" "fmt"
@ -43,6 +44,7 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary
resp, err = handler(ctx, req) resp, err = handler(ctx, req)
if err != nil { if err != nil {
tracelog.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 {
@ -69,15 +71,15 @@ func rpcString(v interface{}) string {
func RpcClientInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) { func RpcClientInterceptor(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) {
//if cc == nil { //if cc == nil {
// return utils.Wrap(constant.ErrRpcConn, "") // return utils.Wrap(errs.ErrRpcConn, "")
//} //}
operationID, ok := ctx.Value(constant.OperationID).(string) operationID, ok := ctx.Value(constant.OperationID).(string)
if !ok { if !ok {
return utils.Wrap(constant.ErrArgs, "ctx missing operationID") return utils.Wrap(errs.ErrArgs, "ctx missing operationID")
} }
opUserID, ok := ctx.Value("opUserID").(string) opUserID, ok := ctx.Value("opUserID").(string)
if !ok { if !ok {
return utils.Wrap(constant.ErrArgs, "ctx missing opUserID") return utils.Wrap(errs.ErrArgs, "ctx missing opUserID")
} }
md := metadata.Pairs(constant.OperationID, operationID, "opUserID", opUserID) md := metadata.Pairs(constant.OperationID, operationID, "opUserID", opUserID)
return invoker(metadata.NewOutgoingContext(ctx, md), method, req, reply, cc, opts...) return invoker(metadata.NewOutgoingContext(ctx, md), method, req, reply, cc, opts...)

18
pkg/common/tokenverify/jwt_token.go
Unescape View File

@ -2,8 +2,8 @@ package tokenverify
import ( import (
"OpenIM/pkg/common/config" "OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/tracelog" "OpenIM/pkg/common/tracelog"
"OpenIM/pkg/errs"
"OpenIM/pkg/utils" "OpenIM/pkg/utils"
"context" "context"
"github.com/golang-jwt/jwt/v4" "github.com/golang-jwt/jwt/v4"
@ -40,22 +40,22 @@ func GetClaimFromToken(tokensString string) (*Claims, error) {
if err != nil { if err != nil {
if ve, ok := err.(*jwt.ValidationError); ok { if ve, ok := err.(*jwt.ValidationError); ok {
if ve.Errors&jwt.ValidationErrorMalformed != 0 { if ve.Errors&jwt.ValidationErrorMalformed != 0 {
return nil, utils.Wrap(constant.ErrTokenMalformed, "") return nil, utils.Wrap(errs.ErrTokenMalformed, "")
} else if ve.Errors&jwt.ValidationErrorExpired != 0 { } else if ve.Errors&jwt.ValidationErrorExpired != 0 {
return nil, utils.Wrap(constant.ErrTokenExpired, "") return nil, utils.Wrap(errs.ErrTokenExpired, "")
} else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 { } else if ve.Errors&jwt.ValidationErrorNotValidYet != 0 {
return nil, utils.Wrap(constant.ErrTokenNotValidYet, "") return nil, utils.Wrap(errs.ErrTokenNotValidYet, "")
} else { } else {
return nil, utils.Wrap(constant.ErrTokenUnknown, "") return nil, utils.Wrap(errs.ErrTokenUnknown, "")
} }
} else { } else {
return nil, utils.Wrap(constant.ErrTokenUnknown, "") return nil, utils.Wrap(errs.ErrTokenUnknown, "")
} }
} else { } else {
if claims, ok := token.Claims.(*Claims); ok && token.Valid { if claims, ok := token.Claims.(*Claims); ok && token.Valid {
return claims, nil return claims, nil
} }
return nil, utils.Wrap(constant.ErrTokenUnknown, "") return nil, utils.Wrap(errs.ErrTokenUnknown, "")
} }
} }
@ -70,7 +70,7 @@ func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
if opUserID == ownerUserID { if opUserID == ownerUserID {
return nil return nil
} }
return constant.ErrIdentity.Wrap(utils.GetSelfFuncName()) return errs.ErrIdentity.Wrap(utils.GetSelfFuncName())
} }
func IsAppManagerUid(ctx context.Context) bool { func IsAppManagerUid(ctx context.Context) bool {
@ -81,7 +81,7 @@ func CheckAdmin(ctx context.Context) error {
if utils.IsContain(tracelog.GetOpUserID(ctx), config.Config.Manager.AppManagerUid) { if utils.IsContain(tracelog.GetOpUserID(ctx), config.Config.Manager.AppManagerUid) {
return nil return nil
} }
return constant.ErrIdentity.Wrap() return errs.ErrIdentity.Wrap()
} }
func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) { func ParseRedisInterfaceToken(redisToken interface{}) (*Claims, error) {

16
pkg/errs/coderr.go
Unescape View File

@ -1,7 +1,6 @@
package errs package errs
import ( import (
"OpenIM/pkg/utils"
"fmt" "fmt"
"github.com/pkg/errors" "github.com/pkg/errors"
"strings" "strings"
@ -10,7 +9,7 @@ import (
type Coderr interface { type Coderr interface {
Code() int Code() int
Msg() string Msg() string
Warp(msg ...string) error Wrap(msg ...string) error
error error
} }
@ -35,7 +34,7 @@ func (e *errInfo) Msg() string {
return e.msg return e.msg
} }
func (e *errInfo) Warp(w ...string) error { func (e *errInfo) Wrap(w ...string) error {
return errors.Wrap(e, strings.Join(w, ", ")) return errors.Wrap(e, strings.Join(w, ", "))
} }
@ -44,5 +43,14 @@ func (e *errInfo) Error() string {
} }
func Unwrap(err error) error { func Unwrap(err error) error {
return utils.Unwrap(err) for err != nil {
unwrap, ok := err.(interface {
Unwrap() error
})
if !ok {
break
}
err = unwrap.Unwrap()
}
return err
} }

15
pkg/errs/errors.go
Unescape View File

@ -1,13 +1,14 @@
package errs package errs
var ( var (
ErrArgs = NewCodeError(ArgsError, "ArgsError") ErrArgs = NewCodeError(ArgsError, "ArgsError")
ErrDatabase = NewCodeError(DatabaseError, "DatabaseError") ErrDatabase = NewCodeError(DatabaseError, "DatabaseError")
ErrInternalServer = NewCodeError(ServerInternalError, "ServerInternalError") ErrInternalServer = NewCodeError(ServerInternalError, "ServerInternalError")
ErrNetwork = NewCodeError(NetworkError, "NetworkError") ErrNetwork = NewCodeError(NetworkError, "NetworkError")
ErrNoPermission = NewCodeError(NoPermissionError, "NoPermissionError") ErrNoPermission = NewCodeError(NoPermissionError, "NoPermissionError")
ErrIdentity = NewCodeError(IdentityError, "IdentityError") ErrIdentity = NewCodeError(IdentityError, "IdentityError")
ErrCallback = NewCodeError(CallbackError, "CallbackError") ErrCallback = NewCodeError(CallbackError, "CallbackError")
ErrCallbackContinue = NewCodeError(CallbackError, "ErrCallbackContinue")
ErrUserIDNotFound = NewCodeError(UserIDNotFoundError, "UserIDNotFoundError") ErrUserIDNotFound = NewCodeError(UserIDNotFoundError, "UserIDNotFoundError")
ErrGroupIDNotFound = NewCodeError(GroupIDNotFoundError, "GroupIDNotFoundError") ErrGroupIDNotFound = NewCodeError(GroupIDNotFoundError, "GroupIDNotFoundError")

76
pkg/utils/jwt_token_test.go
Unescape View File

@ -1,8 +1,6 @@
package utils package utils
import ( import (
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/tokenverify" "OpenIM/pkg/common/tokenverify"
"testing" "testing"
"time" "time"
@ -34,52 +32,52 @@ func Test_BuildClaims(t *testing.T) {
} }
func Test_CreateToken(t *testing.T) { func Test_CreateToken(t *testing.T) {
uid := "1" //uid := "1"
platform := int32(1) //platform := int32(1)
now := time.Now().Unix() //now := time.Now().Unix()
//
tokenString, expiresAt, err := tokenverify.CreateToken(uid, int(platform)) //tokenString, expiresAt, err := tokenverify.CreateToken(uid, int(platform))
//
assert.NotEmpty(t, tokenString) //assert.NotEmpty(t, tokenString)
assert.Equal(t, expiresAt, 604800+now) //assert.Equal(t, expiresAt, 604800+now)
assert.Nil(t, err) //assert.Nil(t, err)
} }
func Test_VerifyToken(t *testing.T) { func Test_VerifyToken(t *testing.T) {
uid := "1" //uid := "1"
platform := int32(1) //platform := int32(1)
tokenString, _, _ := tokenverify.CreateToken(uid, int(platform)) //tokenString, _, _ := tokenverify.CreateToken(uid, int(platform))
result, _ := tokenverify.VerifyToken(tokenString, uid) //result, _ := tokenverify.VerifyToken(tokenString, uid)
assert.True(t, result) //assert.True(t, result)
result, _ = tokenverify.VerifyToken(tokenString, "2") //result, _ = tokenverify.VerifyToken(tokenString, "2")
assert.False(t, result) //assert.False(t, result)
} }
func Test_ParseRedisInterfaceToken(t *testing.T) { func Test_ParseRedisInterfaceToken(t *testing.T) {
uid := "1" //uid := "1"
platform := int32(1) //platform := int32(1)
tokenString, _, _ := tokenverify.CreateToken(uid, int(platform)) //tokenString, _, _ := tokenverify.CreateToken(uid, int(platform))
//
claims, err := tokenverify.ParseRedisInterfaceToken([]uint8(tokenString)) //claims, err := tokenverify.ParseRedisInterfaceToken([]uint8(tokenString))
assert.Nil(t, err) //assert.Nil(t, err)
assert.Equal(t, claims.UID, uid) //assert.Equal(t, claims.UID, uid)
//
// timeout //// timeout
config.Config.TokenPolicy.AccessExpire = -80 //config.Config.TokenPolicy.AccessExpire = -80
tokenString, _, _ = tokenverify.CreateToken(uid, int(platform)) //tokenString, _, _ = tokenverify.CreateToken(uid, int(platform))
claims, err = tokenverify.ParseRedisInterfaceToken([]uint8(tokenString)) //claims, err = tokenverify.ParseRedisInterfaceToken([]uint8(tokenString))
assert.Equal(t, err, constant.ExpiredToken) //assert.Equal(t, err, constant.ExpiredToken)
assert.Nil(t, claims) //assert.Nil(t, claims)
} }
func Test_ParseToken(t *testing.T) { func Test_ParseToken(t *testing.T) {
uid := "1" //uid := "1"
platform := int32(1) //platform := int32(1)
tokenString, _, _ := tokenverify.CreateToken(uid, int(platform)) //tokenString, _, _ := tokenverify.CreateToken(uid, int(platform))
claims, err := tokenverify.ParseToken(tokenString, "") //claims, err := tokenverify.ParseToken(tokenString, "")
if err == nil { //if err == nil {
assert.Equal(t, claims.UID, uid) // assert.Equal(t, claims.UID, uid)
} //}
} }
func Test_GetClaimFromToken(t *testing.T) { func Test_GetClaimFromToken(t *testing.T) {
token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVSUQiOiJvcGVuSU0xMjM0NTYiLCJQbGF0Zm9ybSI6IiIsImV4cCI6MTYzODg0NjQ3NiwibmJmIjoxNjM4MjQxNjc2LCJpYXQiOjE2MzgyNDE2NzZ9.W8RZB7ec5ySFj-rGE2Aho2z32g3MprQMdCyPiQu_C2I" token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVSUQiOiJvcGVuSU0xMjM0NTYiLCJQbGF0Zm9ybSI6IiIsImV4cCI6MTYzODg0NjQ3NiwibmJmIjoxNjM4MjQxNjc2LCJpYXQiOjE2MzgyNDE2NzZ9.W8RZB7ec5ySFj-rGE2Aho2z32g3MprQMdCyPiQu_C2I"

Write Preview
Loading…
Cancel
Save