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

Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

Browse Source 
# Conflicts:
#	pkg/common/config/config.go
#	pkg/discoveryregistry/discovery_register.go
This commit is contained in:
wangchuxiao 2023-02-28 15:28:04 +08:00
commit 2edb3cfd8c
25 changed files with 11327 additions and 4513 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
go.mod
View File

@ -1,6 +1,6 @@
module OpenIM
go 1.16
go 1.18
require (
firebase.google.com/go v3.13.0+incompatible
@ -53,16 +53,97 @@ require (
require github.com/minio/minio-go v6.0.14+incompatible
require (
cloud.google.com/go v0.105.0 // indirect
cloud.google.com/go/compute v1.13.0 // indirect
cloud.google.com/go/compute/metadata v0.2.1 // indirect
cloud.google.com/go/firestore v1.9.0 // indirect
cloud.google.com/go/iam v0.8.0 // indirect
cloud.google.com/go/longrunning v0.3.0 // indirect
cloud.google.com/go/storage v1.27.0 // indirect
github.com/alibabacloud-go/debug v0.0.0-20190504072949-9472017b5c68 // indirect
github.com/alibabacloud-go/endpoint-util v1.1.0 // indirect
github.com/alibabacloud-go/openapi-util v0.0.9 // indirect
github.com/alibabacloud-go/tea-utils v1.3.9 // indirect
github.com/aliyun/credentials-go v1.1.2 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.12.8 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.14 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.8 // indirect
github.com/aws/aws-sdk-go-v2/internal/ini v1.3.15 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.8 // indirect
github.com/aws/aws-sdk-go-v2/service/sso v1.11.12 // indirect
github.com/aws/smithy-go v1.12.0 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/cespare/xxhash/v2 v2.1.2 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/dustin/go-humanize v1.0.0 // indirect
github.com/eapache/go-resiliency v1.2.0 // indirect
github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21 // indirect
github.com/eapache/queue v1.1.0 // indirect
github.com/gin-contrib/sse v0.1.0 // indirect
github.com/go-ini/ini v1.67.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.0 // indirect
github.com/go-sql-driver/mysql v1.6.0 // indirect
github.com/go-stack/stack v1.8.0 // indirect
github.com/go-zookeeper/zk v1.0.3 // indirect
github.com/goccy/go-json v0.10.0 // indirect
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
github.com/golang/snappy v0.0.3 // indirect
github.com/google/go-cmp v0.5.9 // indirect
github.com/google/uuid v1.3.0 // indirect
github.com/googleapis/enterprise-certificate-proxy v0.2.0 // indirect
github.com/googleapis/gax-go/v2 v2.7.0 // indirect
github.com/hashicorp/go-uuid v1.0.2 // indirect
github.com/jcmturner/aescts/v2 v2.0.0 // indirect
github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
github.com/jcmturner/gofork v1.0.0 // indirect
github.com/jcmturner/gokrb5/v8 v8.4.2 // indirect
github.com/jcmturner/rpc/v2 v2.0.3 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/jonboulle/clockwork v0.3.0 // indirect
github.com/josharian/intern v1.0.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/compress v1.13.6 // indirect
github.com/klauspost/cpuid v1.3.1 // indirect
github.com/leodido/go-urn v1.2.1 // indirect
github.com/lestrrat-go/strftime v1.0.6 // indirect
github.com/lithammer/shortuuid v3.0.0+incompatible // indirect
github.com/mailru/easyjson v0.7.7 // indirect
github.com/mattn/go-isatty v0.0.17 // indirect
github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
github.com/minio/md5-simd v1.1.0 // indirect
github.com/minio/sha256-simd v0.1.1 // indirect
github.com/mitchellh/go-homedir v1.1.0 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.0.6 // indirect
github.com/pierrec/lz4 v2.6.0+incompatible // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/prometheus/client_model v0.2.0 // indirect
github.com/prometheus/common v0.37.0 // indirect
github.com/prometheus/procfs v0.8.0 // indirect
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
github.com/rs/xid v1.2.1 // indirect
github.com/tjfoc/gmsm v1.3.2 // indirect
github.com/ugorji/go/codec v1.2.8 // indirect
github.com/xdg-go/pbkdf2 v1.0.0 // indirect
github.com/xdg-go/scram v1.0.2 // indirect
github.com/xdg-go/stringprep v1.0.2 // indirect
github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
go.opencensus.io v0.24.0 // indirect
golang.org/x/crypto v0.5.0 // indirect
golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783 // indirect
golang.org/x/sync v0.1.0 // indirect
golang.org/x/sys v0.4.0 // indirect
golang.org/x/text v0.6.0 // indirect
golang.org/x/time v0.1.0 // indirect
golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
google.golang.org/appengine v1.6.7 // indirect
google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f // indirect
gopkg.in/ini.v1 v1.66.2 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
)
replace github.com/Shopify/sarama => github.com/Shopify/sarama v1.29.0

43
internal/api/a2r/api2rpc.go Normal file
View File

@ -0,0 +1,43 @@
package a2r
import (
"OpenIM/internal/apiresp"
"OpenIM/pkg/common/constant"
"context"
"github.com/gin-gonic/gin"
"google.golang.org/grpc"
"net/http"
)
func Call[A, B, C any](
rpc func(client C, ctx context.Context, req *A, options ...grpc.CallOption) (*B, error),
client func() (C, error),
c *gin.Context,
) {
var resp *apiresp.ApiResponse
defer func() {
c.JSON(http.StatusOK, resp)
}()
var req A
if err := c.BindJSON(&req); err != nil {
resp = apiresp.Error(constant.ErrArgs.Wrap(err.Error())) // 参数错误
return
}
if check, ok := any(&req).(interface{ Check() error }); ok {
if err := check.Check(); err != nil {
resp = apiresp.Error(constant.ErrArgs.Wrap(err.Error())) // 参数校验失败
return
}
}
cli, err := client()
if err != nil {
resp = apiresp.Error(constant.ErrInternalServer.Wrap(err.Error())) // 参数校验失败
return
}
data, err := rpc(cli, c, &req)
if err != nil {
resp = apiresp.Error(err) // 参数校验失败
return
}
resp = apiresp.Success(data) // 成功
}

44
internal/api/auth.go Normal file
View File

@ -0,0 +1,44 @@
package api
import (
"OpenIM/internal/api/a2r"
"OpenIM/pkg/common/config"
auth "OpenIM/pkg/proto/auth"
"context"
"github.com/OpenIMSDK/openKeeper"
"github.com/gin-gonic/gin"
)
var _ context.Context // 解决goland编辑器bug
func NewAuth(zk *openKeeper.ZkClient) *Auth {
return &Auth{zk: zk}
}
type Auth struct {
zk *openKeeper.ZkClient
}
func (a *Auth) getGroupClient() (auth.AuthClient, error) {
conn, err := a.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
if err != nil {
return nil, err
}
return auth.NewAuthClient(conn), nil
}
func (a *Auth) UserRegister(c *gin.Context) {
a2r.Call(auth.AuthClient.UserRegister, a.getGroupClient, c)
}
func (a *Auth) UserToken(c *gin.Context) {
a2r.Call(auth.AuthClient.UserToken, a.getGroupClient, c)
}
func (a *Auth) ParseToken(c *gin.Context) {
a2r.Call(auth.AuthClient.ParseToken, a.getGroupClient, c)
}
func (a *Auth) ForceLogout(c *gin.Context) {
a2r.Call(auth.AuthClient.ForceLogout, a.getGroupClient, c)
}

233
internal/api/auth/auth.go
View File

@ -1,233 +0,0 @@
package apiAuth
import (
api "OpenIM/pkg/apistruct"
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/log"
"OpenIM/pkg/common/tokenverify"
rpc "OpenIM/pkg/proto/auth"
sdkws "OpenIM/pkg/proto/sdkws"
"OpenIM/pkg/utils"
"context"
"net/http"
"strings"
"github.com/fatih/structs"
"github.com/gin-gonic/gin"
)
// @Summary 用户注册
// @Description 用户注册
// @Tags 鉴权认证
// @ID UserRegister
// @Accept json
// @Param req body api.UserRegisterReq true "secret为openIM密钥, 详细见服务端config.yaml secret字段 <br> platform为平台ID <br> ex为拓展字段 <br> gender为性别, 0为女, 1为男"
// @Produce json
// @Success 0 {object} api.UserRegisterResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /auth/user_register [post]
func UserRegister(c *gin.Context) {
params := api.UserRegisterReq{}
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError("0", errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
return
}
if params.Secret != config.Config.Secret {
errMsg := " params.Secret != config.Config.Secret "
log.NewError(params.OperationID, errMsg, params.Secret, config.Config.Secret)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
return
}
req := &rpc.UserRegisterReq{UserInfo: &sdkws.UserInfo{}}
utils.CopyStructFields(req.UserInfo, &params)
//copier.Copy(req.UserInfo, &params)
req.OperationID = params.OperationID
log.NewInfo(req.OperationID, "UserRegister args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewAuthClient(etcdConn)
reply, err := client.UserRegister(context.Background(), req)
if err != nil {
errMsg := req.OperationID + " " + "UserRegister failed " + err.Error() + req.String()
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
if reply.CommonResp.ErrCode != 0 {
errMsg := req.OperationID + " " + " UserRegister failed " + reply.CommonResp.ErrMsg + req.String()
log.NewError(req.OperationID, errMsg)
if reply.CommonResp.ErrCode == constant.RegisterLimit {
c.JSON(http.StatusOK, gin.H{"errCode": constant.RegisterLimit, "errMsg": "用户注册被限制"})
} else if reply.CommonResp.ErrCode == constant.InvitationError {
c.JSON(http.StatusOK, gin.H{"errCode": constant.InvitationError, "errMsg": "邀请码错误"})
} else {
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
}
return
}
pbDataToken := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID}
replyToken, err := client.UserToken(context.Background(), pbDataToken)
if err != nil {
errMsg := req.OperationID + " " + " client.UserToken failed " + err.Error() + pbDataToken.String()
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
resp := api.UserRegisterResp{CommResp: api.CommResp{ErrCode: replyToken.CommonResp.ErrCode, ErrMsg: replyToken.CommonResp.ErrMsg},
UserToken: api.UserTokenInfo{UserID: req.UserInfo.UserID, Token: replyToken.Token, ExpiredTime: replyToken.ExpiredTime}}
log.NewInfo(req.OperationID, "UserRegister return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 用户登录
// @Description 获取用户的token
// @Tags 鉴权认证
// @ID UserToken
// @Accept json
// @Param req body api.UserTokenReq true "secret为openIM密钥, 详细见服务端config.yaml secret字段 <br> platform为平台ID"
// @Produce json
// @Success 0 {object} api.UserTokenResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /auth/user_token [post]
func UserToken(c *gin.Context) {
params := api.UserTokenReq{}
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError(params.OperationID, errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
return
}
if params.Secret != config.Config.Secret {
errMsg := params.OperationID + " params.Secret != config.Config.Secret "
log.NewError(params.OperationID, "params.Secret != config.Config.Secret", params.Secret, config.Config.Secret)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 401, "errMsg": errMsg})
return
}
req := &rpc.UserTokenReq{Platform: params.Platform, FromUserID: params.UserID, OperationID: params.OperationID, LoginIp: params.LoginIp}
log.NewInfo(req.OperationID, "UserToken args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewAuthClient(etcdConn)
reply, err := client.UserToken(context.Background(), req)
if err != nil {
errMsg := req.OperationID + " UserToken failed " + err.Error() + " req: " + req.String()
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
resp := api.UserTokenResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg},
UserToken: api.UserTokenInfo{UserID: req.FromUserID, Token: reply.Token, ExpiredTime: reply.ExpiredTime}}
log.NewInfo(req.OperationID, "UserToken return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 解析当前用户token
// @Description 解析当前用户token(token在请求头中传入)
// @Tags 鉴权认证
// @ID ParseToken
// @Accept json
// @Param token header string true "im token"
// @Param req body api.ParseTokenReq true "secret为openIM密钥, 详细见服务端config.yaml secret字段<br>platform为平台ID"
// @Produce json
// @Success 0 {object} api.ParseTokenResp{Map=api.ExpireTime}
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /auth/parse_token [post]
func ParseToken(c *gin.Context) {
params := api.ParseTokenReq{}
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError("0", errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 1001, "errMsg": errMsg})
return
}
var ok bool
var errInfo string
var expireTime int64
ok, _, errInfo, expireTime = tokenverify.GetUserIDFromTokenExpireTime(c.Request.Header.Get("token"), params.OperationID)
if !ok {
errMsg := params.OperationID + " " + "GetUserIDFromTokenExpireTime failed " + errInfo
log.NewError(params.OperationID, errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 1001, "errMsg": errMsg})
return
}
resp := api.ParseTokenResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, ExpireTime: api.ExpireTime{ExpireTimeSeconds: uint32(expireTime)}}
resp.Data = structs.Map(&resp.ExpireTime)
log.NewInfo(params.OperationID, "ParseToken return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 强制登出
// @Description 对应的平台强制登出
// @Tags 鉴权认证
// @ID ForceLogout
// @Accept json
// @Param token header string true "im token"
// @Param req body api.ForceLogoutReq true "platform为平台ID <br> fromUserID为要执行强制登出的用户ID"
// @Produce json
// @Success 0 {object} api.ForceLogoutResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /auth/force_logout [post]
func ForceLogout(c *gin.Context) {
params := api.ForceLogoutReq{}
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError("0", errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
return
}
req := &rpc.ForceLogoutReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(req.OperationID, "ForceLogout args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAuthName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + " getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewAuthClient(etcdConn)
reply, err := client.ForceLogout(context.Background(), req)
if err != nil {
errMsg := req.OperationID + " UserToken failed " + err.Error() + req.String()
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
resp := api.ForceLogoutResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
log.NewInfo(params.OperationID, utils.GetSelfFuncName(), " return ", resp)
c.JSON(http.StatusOK, resp)
}

76
internal/api/friend.go Normal file
View File

@ -0,0 +1,76 @@
package api
import (
"OpenIM/internal/api/a2r"
"OpenIM/pkg/common/config"
"OpenIM/pkg/proto/friend"
"context"
"github.com/OpenIMSDK/openKeeper"
"github.com/gin-gonic/gin"
)
var _ context.Context // 解决goland编辑器bug
func NewFriend(zk *openKeeper.ZkClient) *Friend {
return &Friend{zk: zk}
}
type Friend struct {
zk *openKeeper.ZkClient
}
func (f *Friend) getGroupClient() (friend.FriendClient, error) {
conn, err := f.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
if err != nil {
return nil, err
}
return friend.NewFriendClient(conn), nil
}
func (f *Friend) AddFriend(c *gin.Context) {
a2r.Call(friend.FriendClient.AddFriend, f.getGroupClient, c)
}
func (f *Friend) DeleteFriend(c *gin.Context) {
a2r.Call(friend.FriendClient.DeleteFriend, f.getGroupClient, c)
}
func (f *Friend) GetFriendApplyList(c *gin.Context) {
a2r.Call(friend.FriendClient.GetFriendApplyList, f.getGroupClient, c)
}
func (f *Friend) GetSelfApplyList(c *gin.Context) {
a2r.Call(friend.FriendClient.GetSelfApplyList, f.getGroupClient, c)
}
func (f *Friend) GetFriendList(c *gin.Context) {
a2r.Call(friend.FriendClient.GetFriendList, f.getGroupClient, c)
}
func (f *Friend) AddFriendResponse(c *gin.Context) {
a2r.Call(friend.FriendClient.AddFriendResponse, f.getGroupClient, c)
}
func (f *Friend) SetFriendRemark(c *gin.Context) {
a2r.Call(friend.FriendClient.SetFriendRemark, f.getGroupClient, c)
}
func (f *Friend) AddBlack(c *gin.Context) {
a2r.Call(friend.FriendClient.AddBlack, f.getGroupClient, c)
}
func (f *Friend) GetBlacklist(c *gin.Context) {
a2r.Call(friend.FriendClient.GetBlacklist, f.getGroupClient, c)
}
func (f *Friend) RemoveBlacklist(c *gin.Context) {
a2r.Call(friend.FriendClient.RemoveBlacklist, f.getGroupClient, c)
}
func (f *Friend) ImportFriend(c *gin.Context) {
a2r.Call(friend.FriendClient.ImportFriend, f.getGroupClient, c)
}
func (f *Friend) IsFriend(c *gin.Context) {
a2r.Call(friend.FriendClient.IsFriend, f.getGroupClient, c)
}

678
internal/api/friend/friend.go
View File

@ -1,678 +0,0 @@
package friend
//import (
// jsonData "OpenIM/internal/utils"
// api "OpenIM/pkg/apistruct"
// "OpenIM/pkg/common/config"
// "OpenIM/pkg/common/log"
// "OpenIM/pkg/common/tokenverify"
// "OpenIM/pkg/getcdv3"
// rpc "OpenIM/pkg/proto/friend"
// sdkws "OpenIM/pkg/proto/sdkws"
// "OpenIM/pkg/utils"
// "context"
// "github.com/gin-gonic/gin"
// "net/http"
// "strings"
//)
//
//// @Summary 添加黑名单
//// @Description 添加黑名单
//// @Tags 好友相关
//// @ID AddBlack
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.AddBlacklistReq true "fromUserID为设置的用户 <br> toUserID为被设置的用户"
//// @Produce json
//// @Success 0 {object} api.AddBlacklistResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/add_black [post]
//func AddBlack(c *gin.Context) {
// params := api.AddBlacklistReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.AddBlacklistReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params)
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// log.NewInfo(params.OperationID, "AddBlacklist args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.AddBlacklist(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "AddBlacklist failed ", err.Error())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add blacklist rpc server failed"})
// return
// }
// resp := api.AddBlacklistResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// log.NewInfo(req.CommID.OperationID, "AddBlacklist api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 批量加好友
//// @Description 批量加好友
//// @Tags 好友相关
//// @ID ImportFriend
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.ImportFriendReq true "fromUserID批量加好友的用户ID<br> friendUserIDList为"
//// @Produce json
//// @Success 0 {object} api.ImportFriendResp "data列表中对象的result-1为添加该用户失败<br>0为成功"
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/import_friend [post]
//func ImportFriend(c *gin.Context) {
// params := api.ImportFriendReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.ImportFriendReq{}
// utils.CopyStructFields(req, &params)
// var ok bool
// var errInfo string
// ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
// if !ok {
// errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.OperationID, "ImportFriend args ", req.String())
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.OperationID)
// if etcdConn == nil {
// errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.ImportFriend(context.Background(), req)
// if err != nil {
// log.NewError(req.OperationID, "ImportFriend failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "ImportFriend failed "})
// return
// }
// resp := api.ImportFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// if resp.ErrCode == 0 {
// for _, v := range RpcResp.UserIDResultList {
// resp.UserIDResultList = append(resp.UserIDResultList, api.UserIDResult{UserID: v.UserID, Result: v.Result})
// }
// }
// if len(resp.UserIDResultList) == 0 {
// resp.UserIDResultList = []api.UserIDResult{}
// }
// log.NewInfo(req.OperationID, "ImportFriend api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 添加好友
//// @Description 添加好友
//// @Tags 好友相关
//// @ID AddFriend
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.AddFriendReq true "reqMsg为申请信息 <br> fromUserID为申请用户 <br> toUserID为被添加用户"
//// @Produce json
//// @Success 0 {object} api.AddFriendResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/add_friend [post]
//func AddFriend(c *gin.Context) {
// params := api.AddFriendReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.AddFriendReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
// req.ReqMsg = params.ReqMsg
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "AddFriend args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.AddFriend(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "AddFriend failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call AddFriend rpc server failed"})
// return
// }
//
// resp := api.AddFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// log.NewInfo(req.CommID.OperationID, "AddFriend api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 同意/拒绝好友请求
//// @Description 同意/拒绝好友请求
//// @Tags 好友相关
//// @ID AddFriendResponse
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.AddFriendResponseReq true "fromUserID同意/拒绝的用户ID<br>toUserID为申请用户D<br>handleMsg为处理信息<br>flag为具体操作, 1为同意, 2为拒绝"
//// @Produce json
//// @Success 0 {object} api.AddFriendResponseResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/add_friend_response [post]
//func AddFriendResponse(c *gin.Context) {
// params := api.AddFriendResponseReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.AddFriendResponseReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
// req.HandleMsg = params.HandleMsg
// req.HandleResult = params.Flag
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
// return
// }
//
// utils.CopyStructFields(req, &params)
// log.NewInfo(req.CommID.OperationID, "AddFriendResponse args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.AddFriendResponse(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "AddFriendResponse failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add_friend_response rpc server failed"})
// return
// }
//
// resp := api.AddFriendResponseResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// log.NewInfo(req.CommID.OperationID, "AddFriendResponse api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 删除好友
//// @Description 删除好友
//// @Tags 好友相关
//// @ID DeleteFriend
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.DeleteFriendReq true "fromUserID为操作用户<br>toUserID为被删除用户"
//// @Produce json
//// @Success 0 {object} api.DeleteFriendResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/delete_friend [post]
//func DeleteFriend(c *gin.Context) {
// params := api.DeleteFriendReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.DeleteFriendReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "DeleteFriend args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.DeleteFriend(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "DeleteFriend failed ", err, req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call delete_friend rpc server failed"})
// return
// }
//
// resp := api.DeleteFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// log.NewInfo(req.CommID.OperationID, "DeleteFriend api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 获取黑名单列表
//// @Description 获取黑名单列表
//// @Tags 好友相关
//// @ID GetBlacklist
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.GetBlackListReq true "fromUserID要获取黑名单的用户"
//// @Produce json
//// @Success 0 {object} api.GetBlackListResp{data=[]sdkws.PublicUserInfo}
//// @Failure 500 {object} api.Swagger400Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger500Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/get_black_list [post]
//func GetBlacklist(c *gin.Context) {
// params := api.GetBlackListReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.GetBlacklistReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "GetBlacklist args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.GetBlacklist(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "GetBlacklist failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get blacklist rpc server failed"})
// return
// }
//
// resp := api.GetBlackListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// for _, v := range RpcResp.BlackUserInfoList {
// black := sdkws.PublicUserInfo{}
// utils.CopyStructFields(&black, v)
// resp.BlackUserInfoList = append(resp.BlackUserInfoList, &black)
// }
// resp.Map = jsonData.JsonDataList(resp.BlackUserInfoList)
// log.NewInfo(req.CommID.OperationID, "GetBlacklist api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 设置好友备注
//// @Description 设置好友备注
//// @Tags 好友相关
//// @ID SetFriendRemark
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.SetFriendRemarkReq true "fromUserID为设置的用户<br> toUserID为被设置的用户<br> remark为好友备注"
//// @Produce json
//// @Success 0 {object} api.SetFriendRemarkResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/set_friend_remark [post]
//func SetFriendRemark(c *gin.Context) {
// params := api.SetFriendRemarkReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.SetFriendRemarkReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
// req.Remark = params.Remark
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "SetFriendComment args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.SetFriendRemark(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "SetFriendComment failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call set friend comment rpc server failed"})
// return
// }
// resp := api.SetFriendRemarkResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
//
// log.NewInfo(req.CommID.OperationID, "SetFriendComment api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 把用户移除黑名单
//// @Description 把用户移除黑名单
//// @Tags 好友相关
//// @ID RemoveBlacklist
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.RemoveBlackListReq true "fromUserID要获取黑名单的用户"
//// @Produce json
//// @Success 0 {object} api.RemoveBlackListResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/remove_black [post]
//func RemoveBlacklist(c *gin.Context) {
// params := api.RemoveBlackListReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.RemoveBlacklistReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "RemoveBlacklist args ", req.String())
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.RemoveBlacklist(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "RemoveBlacklist failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call remove blacklist rpc server failed"})
// return
// }
// resp := api.RemoveBlackListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// log.NewInfo(req.CommID.OperationID, "RemoveBlacklist api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 检查用户之间是否为好友
//// @Description 检查用户之间是否为好友
//// @Tags 好友相关
//// @ID IsFriend
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.IsFriendReq true "fromUserID为请求用户<br> toUserID为要检查的用户"
//// @Produce json
//// @Success 0 {object} api.IsFriendResp
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/is_friend [post]
//func IsFriend(c *gin.Context) {
// params := api.IsFriendReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.IsFriendReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params.ParamsCommFriend)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "IsFriend args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.IsFriend(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "IsFriend failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call add friend rpc server failed"})
// return
// }
// resp := api.IsFriendResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
// resp.Response.Friend = RpcResp.Response
//
// log.NewInfo(req.CommID.OperationID, "IsFriend api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 获取用户的好友列表
//// @Description 获取用户的好友列表
//// @Tags 好友相关
//// @ID GetFriendList
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.GetFriendListReq true "fromUserID为要获取好友列表的用户ID"
//// @Produce json
//// @Success 0 {object} api.GetFriendListResp{data=[]sdkws.FriendInfo}
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/get_friend_list [post]
//func GetFriendList(c *gin.Context) {
// params := api.GetFriendListReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.GetFriendListReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "GetFriendList args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.GetFriendList(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "GetFriendList failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get friend list rpc server failed"})
// return
// }
//
// resp := api.GetFriendListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, FriendInfoList: RpcResp.FriendInfoList}
// resp.Map = jsonData.JsonDataList(resp.FriendInfoList)
// log.NewInfo(req.CommID.OperationID, "GetFriendList api return ", resp)
// c.JSON(http.StatusOK, resp)
// //c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 获取好友申请列表
//// @Description 删除好友
//// @Tags 好友相关
//// @ID GetFriendApplyList
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.GetFriendApplyListReq true "fromUserID为要获取申请列表的用户ID"
//// @Produce json
//// @Success 0 {object} api.GetFriendApplyListResp{data=[]sdkws.FriendRequest}
//// @Failure 500 {object} api.Swagger400Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/get_friend_apply_list [post]
//func GetFriendApplyList(c *gin.Context) {
// params := api.GetFriendApplyListReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.GetFriendApplyListReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "GetFriendApplyList args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
//
// RpcResp, err := client.GetFriendApplyList(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "GetFriendApplyList failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get friend apply list rpc server failed"})
// return
// }
//
// resp := api.GetFriendApplyListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, FriendRequestList: RpcResp.FriendRequestList}
// resp.Map = jsonData.JsonDataList(resp.FriendRequestList)
// log.NewInfo(req.CommID.OperationID, "GetFriendApplyList api return ", resp)
// c.JSON(http.StatusOK, resp)
//}
//
//// @Summary 获取自己的好友申请列表
//// @Description 获取自己的好友申请列表
//// @Tags 好友相关
//// @ID GetSelfApplyList
//// @Accept json
//// @Param token header string true "im token"
//// @Param req body api.GetSelfApplyListReq true "fromUserID为自己的用户ID"
//// @Produce json
//// @Success 0 {object} api.GetSelfApplyListResp{data=[]sdkws.FriendRequest}
//// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
//// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
//// @Router /friend/get_self_friend_apply_list [post]
//func GetSelfApplyList(c *gin.Context) {
// params := api.GetSelfApplyListReq{}
// if err := c.BindJSON(&params); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// req := &rpc.GetSelfApplyListReq{CommID: &rpc.CommID{}}
// utils.CopyStructFields(req.CommID, &params)
//
// var ok bool
// var errInfo string
// ok, req.CommID.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.CommID.OperationID)
// if !ok {
// errMsg := req.CommID.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
//
// log.NewInfo(req.CommID.OperationID, "GetSelfApplyList args ", req.String())
//
// etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImFriendName, req.CommID.OperationID)
// if etcdConn == nil {
// errMsg := req.CommID.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.CommID.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewFriendClient(etcdConn)
// RpcResp, err := client.GetSelfApplyList(context.Background(), req)
// if err != nil {
// log.NewError(req.CommID.OperationID, "GetSelfApplyList failed ", err.Error(), req.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call get self apply list rpc server failed"})
// return
// }
// resp := api.GetSelfApplyListResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, FriendRequestList: RpcResp.FriendRequestList}
// resp.Map = jsonData.JsonDataList(resp.FriendRequestList)
// log.NewInfo(req.CommID.OperationID, "GetSelfApplyList api return ", resp)
// c.JSON(http.StatusOK, resp)
//}

57
internal/api/friend/friend1.go
View File

@ -1,57 +0,0 @@
package friend
import (
common "OpenIM/internal/api2rpc"
api "OpenIM/pkg/apistruct"
"OpenIM/pkg/common/config"
rpc "OpenIM/pkg/proto/friend"
"github.com/gin-gonic/gin"
)
func AddBlack(c *gin.Context) {
common.ApiToRpc(c, &api.AddBlacklistReq{}, &api.AddBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func ImportFriend(c *gin.Context) {
common.ApiToRpc(c, &api.ImportFriendReq{}, &api.ImportFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func AddFriend(c *gin.Context) {
common.ApiToRpc(c, &api.AddFriendReq{}, &api.AddFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func AddFriendResponse(c *gin.Context) {
common.ApiToRpc(c, &api.AddFriendResponseReq{}, &api.AddFriendResponseResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func DeleteFriend(c *gin.Context) {
common.ApiToRpc(c, &api.DeleteFriendReq{}, &api.DeleteFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func GetBlacklist(c *gin.Context) {
common.ApiToRpc(c, &api.GetBlackListReq{}, &api.GetBlackListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func SetFriendRemark(c *gin.Context) {
common.ApiToRpc(c, &api.SetFriendRemarkReq{}, &api.SetFriendRemarkResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func RemoveBlacklist(c *gin.Context) {
common.ApiToRpc(c, &api.RemoveBlacklistReq{}, &api.RemoveBlacklistResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func IsFriend(c *gin.Context) {
common.ApiToRpc(c, &api.IsFriendReq{}, &api.IsFriendResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func GetFriendList(c *gin.Context) {
common.ApiToRpc(c, &api.GetFriendListReq{}, &api.GetFriendListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func GetFriendApplyList(c *gin.Context) {
common.ApiToRpc(c, &api.GetFriendApplyListReq{}, &api.GetFriendApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}
func GetSelfApplyList(c *gin.Context) {
common.ApiToRpc(c, &api.GetSelfApplyListReq{}, &api.GetSelfApplyListResp{}, config.Config.RpcRegisterName.OpenImFriendName, rpc.NewFriendClient, "")
}

124
internal/api/group.go Normal file
View File

@ -0,0 +1,124 @@
package api
import (
"OpenIM/internal/api/a2r"
"OpenIM/pkg/common/config"
"OpenIM/pkg/proto/group"
"context"
"github.com/OpenIMSDK/openKeeper"
"github.com/gin-gonic/gin"
)
var _ context.Context // 解决goland编辑器bug
func NewGroup(zk *openKeeper.ZkClient) *Group {
return &Group{zk: zk}
}
type Group struct {
zk *openKeeper.ZkClient
}
func (g *Group) getGroupClient() (group.GroupClient, error) {
conn, err := g.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
if err != nil {
return nil, err
}
return group.NewGroupClient(conn), nil
}
func (g *Group) NewCreateGroup(c *gin.Context) {
a2r.Call(group.GroupClient.CreateGroup, g.getGroupClient, c)
}
func (g *Group) NewSetGroupInfo(c *gin.Context) {
a2r.Call(group.GroupClient.SetGroupInfo, g.getGroupClient, c)
}
func (g *Group) JoinGroup(c *gin.Context) {
a2r.Call(group.GroupClient.JoinGroup, g.getGroupClient, c)
}
func (g *Group) QuitGroup(c *gin.Context) {
a2r.Call(group.GroupClient.QuitGroup, g.getGroupClient, c)
}
func (g *Group) ApplicationGroupResponse(c *gin.Context) {
a2r.Call(group.GroupClient.GroupApplicationResponse, g.getGroupClient, c)
}
func (g *Group) TransferGroupOwner(c *gin.Context) {
a2r.Call(group.GroupClient.TransferGroupOwner, g.getGroupClient, c)
}
func (g *Group) GetRecvGroupApplicationList(c *gin.Context) {
a2r.Call(group.GroupClient.GetGroupApplicationList, g.getGroupClient, c)
}
func (g *Group) GetUserReqGroupApplicationList(c *gin.Context) {
a2r.Call(group.GroupClient.GetUserReqApplicationList, g.getGroupClient, c)
}
func (g *Group) GetGroupsInfo(c *gin.Context) {
a2r.Call(group.GroupClient.GetGroupsInfo, g.getGroupClient, c)
}
func (g *Group) KickGroupMember(c *gin.Context) {
a2r.Call(group.GroupClient.KickGroupMember, g.getGroupClient, c)
}
func (g *Group) GetGroupMembersInfo(c *gin.Context) {
a2r.Call(group.GroupClient.GetGroupMembersInfo, g.getGroupClient, c)
}
func (g *Group) InviteUserToGroup(c *gin.Context) {
a2r.Call(group.GroupClient.InviteUserToGroup, g.getGroupClient, c)
}
func (g *Group) GetJoinedGroupList(c *gin.Context) {
a2r.Call(group.GroupClient.GetJoinedGroupList, g.getGroupClient, c)
}
func (g *Group) DismissGroup(c *gin.Context) {
a2r.Call(group.GroupClient.DismissGroup, g.getGroupClient, c)
}
func (g *Group) MuteGroupMember(c *gin.Context) {
a2r.Call(group.GroupClient.MuteGroupMember, g.getGroupClient, c)
}
func (g *Group) CancelMuteGroupMember(c *gin.Context) {
a2r.Call(group.GroupClient.CancelMuteGroupMember, g.getGroupClient, c)
}
func (g *Group) MuteGroup(c *gin.Context) {
a2r.Call(group.GroupClient.MuteGroup, g.getGroupClient, c)
}
func (g *Group) CancelMuteGroup(c *gin.Context) {
a2r.Call(group.GroupClient.CancelMuteGroup, g.getGroupClient, c)
}
func (g *Group) SetGroupMemberInfo(c *gin.Context) {
a2r.Call(group.GroupClient.SetGroupMemberInfo, g.getGroupClient, c)
}
func (g *Group) GetGroupAbstractInfo(c *gin.Context) {
a2r.Call(group.GroupClient.GetGroupAbstractInfo, g.getGroupClient, c)
}
//func (g *Group) SetGroupMemberNickname(c *gin.Context) {
// a2r.Call(group.GroupClient.SetGroupMemberNickname, g.getGroupClient, c)
//}
//
//func (g *Group) GetGroupAllMemberList(c *gin.Context) {
// a2r.Call(group.GroupClient.GetGroupAllMember, g.getGroupClient, c)
//}
func (g *Group) GetJoinedSuperGroupList(c *gin.Context) {
a2r.Call(group.GroupClient.GetJoinedSuperGroupList, g.getGroupClient, c)
}
func (g *Group) GetSuperGroupsInfo(c *gin.Context) {
a2r.Call(group.GroupClient.GetSuperGroupsInfo, g.getGroupClient, c)
}

1249
internal/api/group/group.go
View File

File diff suppressed because it is too large Load Diff

35
internal/api/group/group1.go
View File

@ -1,35 +0,0 @@
package group
import (
"OpenIM/internal/api2rpc"
"OpenIM/pkg/apistruct"
"OpenIM/pkg/common/config"
"OpenIM/pkg/proto/group"
"github.com/OpenIMSDK/openKeeper"
"github.com/gin-gonic/gin"
)
type Group struct {
zk *openKeeper.ZkClient
}
func (g *Group) getGroupClient() (group.GroupClient, error) {
conn, err := g.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
if err != nil {
return nil, err
}
return group.NewGroupClient(conn), nil
}
func (g *Group) KickGroupMember(c *gin.Context) {
api2rpc.Rpc(
&apistruct.KickGroupMemberReq{},
&apistruct.KickGroupMemberResp{},
group.GroupClient.KickGroupMember,
).Must(c, g.getGroupClient).Call()
}
//func (g *Group) KickGroupMember1(c *gin.Context) {
// var fn func(client group.GroupClient, ctx context.Context, in *group.KickGroupMemberReq, opts ...grpc.CallOption) (*group.KickGroupMemberResp, error) = group.GroupClient.KickGroupMember
// api2rpc.Rpc(&apistruct.KickGroupMemberReq{}, &apistruct.KickGroupMemberResp{}, fn).Must(c, g.getGroupClient).Call()
//}

10
internal/api/group/group1_test.go
View File

@ -1,10 +0,0 @@
package group
import "testing"
func TestName(t *testing.T) {
var g Group
g.KickGroupMember(nil)
}

89
internal/api/group/super_group.go
View File

@ -1,89 +0,0 @@
package group
//import (
// jsonData "OpenIM/internal/utils"
// api "OpenIM/pkg/apistruct"
// "OpenIM/pkg/common/config"
// "OpenIM/pkg/common/log"
// "OpenIM/pkg/common/token_verify"
// "OpenIM/pkg/getcdv3"
// rpc "OpenIM/pkg/proto/group"
// "OpenIM/pkg/utils"
// "context"
// "github.com/gin-gonic/gin"
// "net/http"
// "strings"
//)
//
//func GetJoinedSuperGroupList(c *gin.Context) {
// req := api.GetJoinedSuperGroupListReq{}
// if err := c.BindJSON(&req); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
// ok, opUserID, errInfo := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
// if !ok {
// errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// reqPb := rpc.GetJoinedSuperGroupListReq{OperationID: req.OperationID, OpUserID: opUserID, UserID: req.FromUserID}
// etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
// if etcdConn == nil {
// errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewGroupClient(etcdConn)
// rpcResp, err := client.GetJoinedSuperGroupList(context.Background(), &reqPb)
// if err != nil {
// log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), reqPb.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
// return
// }
// GroupListResp := api.GetJoinedSuperGroupListResp{GetJoinedGroupListResp: api.GetJoinedGroupListResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, GroupInfoList: rpcResp.GroupList}}
// GroupListResp.Map = jsonData.JsonDataList(GroupListResp.GroupInfoList)
// log.NewInfo(req.OperationID, "GetJoinedSuperGroupList api return ", GroupListResp)
// c.JSON(http.StatusOK, GroupListResp)
//}
//
//func GetSuperGroupsInfo(c *gin.Context) {
// req := api.GetSuperGroupsInfoReq{}
// if err := c.BindJSON(&req); err != nil {
// log.NewError("0", "BindJSON failed ", err.Error())
// c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
// return
// }
// log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
// ok, opUserID, errInfo := token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
// if !ok {
// errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// reqPb := rpc.GetSuperGroupsInfoReq{OperationID: req.OperationID, OpUserID: opUserID, GroupIDList: req.GroupIDList}
// etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
// if etcdConn == nil {
// errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
// log.NewError(req.OperationID, errMsg)
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
// return
// }
// client := rpc.NewGroupClient(etcdConn)
// rpcResp, err := client.GetSuperGroupsInfo(context.Background(), &reqPb)
// if err != nil {
// log.NewError(req.OperationID, "InviteUserToGroup failed ", err.Error(), reqPb.String())
// c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
// return
// }
//
// resp := api.GetSuperGroupsInfoResp{GetGroupInfoResp: api.GetGroupInfoResp{CommResp: api.CommResp{ErrCode: rpcResp.CommonResp.ErrCode, ErrMsg: rpcResp.CommonResp.ErrMsg}, GroupInfoList: rpcResp.GroupInfoList}}
// resp.Map = jsonData.JsonDataList(resp.GroupInfoList)
// log.NewInfo(req.OperationID, "GetGroupsInfo api return ", resp)
// c.JSON(http.StatusOK, resp)
//}

128
internal/api/route.go
View File

@ -1,19 +1,14 @@
package api
import (
"OpenIM/internal/api/auth"
"OpenIM/internal/api/conversation"
"OpenIM/internal/api/friend"
"OpenIM/internal/api/group"
"OpenIM/internal/api/manage"
"OpenIM/internal/api/msg"
"OpenIM/internal/api/third"
"OpenIM/internal/api/user"
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/log"
"OpenIM/pkg/common/middleware"
"OpenIM/pkg/common/prome"
"OpenIM/pkg/common/tokenverify"
"github.com/gin-gonic/gin"
"io"
"os"
@ -35,90 +30,79 @@ func NewGinRouter() *gin.Engine {
r.Use(prome.PrometheusMiddleware)
r.GET("/metrics", prome.PrometheusHandler())
}
userRouterGroup := r.Group("/user")
{
userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) //1
userRouterGroup.POST("/set_global_msg_recv_opt", user.SetGlobalRecvMessageOpt)
userRouterGroup.POST("/get_users_info", user.GetUsersPublicInfo) //1
userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1
userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //1
userRouterGroup.POST("/get_users_info_from_cache", user.GetUsersInfoFromCache)
userRouterGroup.POST("/get_user_friend_from_cache", user.GetFriendIDListFromCache)
userRouterGroup.POST("/get_black_list_from_cache", user.GetBlackIDListFromCache)
userRouterGroup.POST("/get_all_users_uid", manage.GetAllUsersUid) //1
userRouterGroup.POST("/account_check", manage.AccountCheck) //1
// userRouterGroup.POST("/get_users_online_status", manage.GetUsersOnlineStatus) //1
userRouterGroup.POST("/get_users", user.GetUsers)
u := NewUser(nil)
userRouterGroup.POST("/update_user_info", u.UpdateUserInfo) //1
userRouterGroup.POST("/set_global_msg_recv_opt", u.SetGlobalRecvMessageOpt)
userRouterGroup.POST("/get_users_info", u.GetUsersPublicInfo) //1
userRouterGroup.POST("/get_self_user_info", u.GetSelfUserInfo) //1
userRouterGroup.POST("/get_users_online_status", u.GetUsersOnlineStatus) //1
userRouterGroup.POST("/get_users_info_from_cache", u.GetUsersInfoFromCache)
userRouterGroup.POST("/get_user_friend_from_cache", u.GetFriendIDListFromCache)
userRouterGroup.POST("/get_black_list_from_cache", u.GetBlackIDListFromCache)
//userRouterGroup.POST("/get_all_users_uid", manage.GetAllUsersUid) // todo
//userRouterGroup.POST("/account_check", manage.AccountCheck) // todo
userRouterGroup.POST("/get_users", u.GetUsers)
}
////friend routing group
friendRouterGroup := r.Group("/friend")
{
// friendRouterGroup.POST("/get_friends_info", friend.GetFriendsInfo)
friendRouterGroup.POST("/add_friend", friend.AddFriend) //1
friendRouterGroup.POST("/delete_friend", friend.DeleteFriend) //1
friendRouterGroup.POST("/get_friend_apply_list", friend.GetFriendApplyList) //1
friendRouterGroup.POST("/get_self_friend_apply_list", friend.GetSelfApplyList) //1
friendRouterGroup.POST("/get_friend_list", friend.GetFriendList) //1
friendRouterGroup.POST("/add_friend_response", friend.AddFriendResponse) //1
friendRouterGroup.POST("/set_friend_remark", friend.SetFriendRemark) //1
f := NewFriend(nil)
friendRouterGroup.POST("/add_friend", f.AddFriend) //1
friendRouterGroup.POST("/delete_friend", f.DeleteFriend) //1
friendRouterGroup.POST("/get_friend_apply_list", f.GetFriendApplyList) //1
friendRouterGroup.POST("/get_self_friend_apply_list", f.GetSelfApplyList) //1
friendRouterGroup.POST("/get_friend_list", f.GetFriendList) //1
friendRouterGroup.POST("/add_friend_response", f.AddFriendResponse) //1
friendRouterGroup.POST("/set_friend_remark", f.SetFriendRemark) //1
friendRouterGroup.POST("/add_black", f.AddBlack) //1
friendRouterGroup.POST("/get_black_list", f.GetBlacklist) //1
friendRouterGroup.POST("/remove_black", f.RemoveBlacklist) //1
friendRouterGroup.POST("/import_friend", f.ImportFriend) //1
friendRouterGroup.POST("/is_friend", f.IsFriend) //1
friendRouterGroup.POST("/add_black", friend.AddBlack) //1
friendRouterGroup.POST("/get_black_list", friend.GetBlacklist) //1
friendRouterGroup.POST("/remove_black", friend.RemoveBlacklist) //1
friendRouterGroup.POST("/import_friend", friend.ImportFriend) //1
friendRouterGroup.POST("/is_friend", friend.IsFriend) //1
}
//group related routing group
groupRouterGroup := r.Group("/group")
groupRouterGroup.Use(func(c *gin.Context) {
userID, err := tokenverify.ParseUserIDFromToken(c.GetHeader("token"), c.GetString("operationID"))
if err != nil {
c.String(400, err.Error())
c.Abort()
return
}
c.Set("opUserID", userID)
c.Next()
})
g := NewGroup(nil)
{
groupRouterGroup.POST("/create_group", group.NewCreateGroup) //1
groupRouterGroup.POST("/set_group_info", group.NewSetGroupInfo) //1
groupRouterGroup.POST("/join_group", group.JoinGroup) //1
groupRouterGroup.POST("/quit_group", group.QuitGroup) //1
groupRouterGroup.POST("/group_application_response", group.ApplicationGroupResponse) //1
groupRouterGroup.POST("/transfer_group", group.TransferGroupOwner) //1
groupRouterGroup.POST("/get_recv_group_applicationList", group.GetRecvGroupApplicationList) //1
groupRouterGroup.POST("/get_user_req_group_applicationList", group.GetUserReqGroupApplicationList)
groupRouterGroup.POST("/get_groups_info", group.GetGroupsInfo) //1
groupRouterGroup.POST("/kick_group", group.KickGroupMember) //1
// groupRouterGroup.POST("/get_group_member_list", group.FindGroupMemberAll) //no use
groupRouterGroup.POST("/get_group_all_member_list", group.GetGroupAllMemberList) //1
groupRouterGroup.POST("/get_group_members_info", group.GetGroupMembersInfo) //1
groupRouterGroup.POST("/invite_user_to_group", group.InviteUserToGroup) //1
groupRouterGroup.POST("/get_joined_group_list", group.GetJoinedGroupList)
groupRouterGroup.POST("/dismiss_group", group.DismissGroup) //
groupRouterGroup.POST("/mute_group_member", group.MuteGroupMember)
groupRouterGroup.POST("/cancel_mute_group_member", group.CancelMuteGroupMember) //MuteGroup
groupRouterGroup.POST("/mute_group", group.MuteGroup)
groupRouterGroup.POST("/cancel_mute_group", group.CancelMuteGroup)
groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname)
groupRouterGroup.POST("/set_group_member_info", group.SetGroupMemberInfo)
groupRouterGroup.POST("/get_group_abstract_info", group.GetGroupAbstractInfo)
//groupRouterGroup.POST("/get_group_all_member_list_by_split", group.GetGroupAllMemberListBySplit)
groupRouterGroup.POST("/create_group", g.NewCreateGroup) //1
groupRouterGroup.POST("/set_group_info", g.NewSetGroupInfo) //1
groupRouterGroup.POST("/join_group", g.JoinGroup) //1
groupRouterGroup.POST("/quit_group", g.QuitGroup) //1
groupRouterGroup.POST("/group_application_response", g.ApplicationGroupResponse) //1
groupRouterGroup.POST("/transfer_group", g.TransferGroupOwner) //1
groupRouterGroup.POST("/get_recv_group_applicationList", g.GetRecvGroupApplicationList) //1
groupRouterGroup.POST("/get_user_req_group_applicationList", g.GetUserReqGroupApplicationList)
groupRouterGroup.POST("/get_groups_info", g.GetGroupsInfo) //1
groupRouterGroup.POST("/kick_group", g.KickGroupMember) //1
//groupRouterGroup.POST("/get_group_all_member_list", g.GetGroupAllMemberList) //1
groupRouterGroup.POST("/get_group_members_info", g.GetGroupMembersInfo) //1
groupRouterGroup.POST("/invite_user_to_group", g.InviteUserToGroup) //1
groupRouterGroup.POST("/get_joined_group_list", g.GetJoinedGroupList)
groupRouterGroup.POST("/dismiss_group", g.DismissGroup) //
groupRouterGroup.POST("/mute_group_member", g.MuteGroupMember)
groupRouterGroup.POST("/cancel_mute_group_member", g.CancelMuteGroupMember) //MuteGroup
groupRouterGroup.POST("/mute_group", g.MuteGroup)
groupRouterGroup.POST("/cancel_mute_group", g.CancelMuteGroup)
//groupRouterGroup.POST("/set_group_member_nickname", g.SetGroupMemberNickname)
groupRouterGroup.POST("/set_group_member_info", g.SetGroupMemberInfo)
groupRouterGroup.POST("/get_group_abstract_info", g.GetGroupAbstractInfo)
}
superGroupRouterGroup := r.Group("/super_group")
{
superGroupRouterGroup.POST("/get_joined_group_list", group.GetJoinedSuperGroupList)
superGroupRouterGroup.POST("/get_groups_info", group.GetSuperGroupsInfo)
superGroupRouterGroup.POST("/get_joined_group_list", g.GetJoinedSuperGroupList)
superGroupRouterGroup.POST("/get_groups_info", g.GetSuperGroupsInfo)
}
////certificate
authRouterGroup := r.Group("/auth")
{
authRouterGroup.POST("/user_register", apiAuth.UserRegister) //1
authRouterGroup.POST("/user_token", apiAuth.UserToken) //1
authRouterGroup.POST("/parse_token", apiAuth.ParseToken) //1
authRouterGroup.POST("/force_logout", apiAuth.ForceLogout) //1
a := NewAuth(nil)
authRouterGroup.POST("/user_register", a.UserRegister) //1
authRouterGroup.POST("/user_token", a.UserToken) //1
authRouterGroup.POST("/parse_token", a.ParseToken) //1
authRouterGroup.POST("/force_logout", a.ForceLogout) //1
}
////Third service
thirdGroup := r.Group("/third")

72
internal/api/user.go Normal file
View File

@ -0,0 +1,72 @@
package api
import (
"OpenIM/internal/api/a2r"
"OpenIM/pkg/common/config"
"OpenIM/pkg/proto/user"
"context"
"github.com/OpenIMSDK/openKeeper"
"github.com/gin-gonic/gin"
)
var _ context.Context // 解决goland编辑器bug
func NewUser(zk *openKeeper.ZkClient) *User {
return &User{zk: zk}
}
type User struct {
zk *openKeeper.ZkClient
}
func (u *User) getGroupClient() (user.UserClient, error) {
conn, err := u.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
if err != nil {
return nil, err
}
return user.NewUserClient(conn), nil
}
func (u *User) UpdateUserInfo(c *gin.Context) {
a2r.Call(user.UserClient.UpdateUserInfo, u.getGroupClient, c)
}
func (u *User) SetGlobalRecvMessageOpt(c *gin.Context) {
a2r.Call(user.UserClient.SetGlobalRecvMessageOpt, u.getGroupClient, c)
}
func (u *User) GetUsersPublicInfo(c *gin.Context) {
a2r.Call(user.UserClient.GetDesignateUsers, u.getGroupClient, c)
}
func (u *User) GetSelfUserInfo(c *gin.Context) {
a2r.Call(user.UserClient.GetSelfUserInfo, u.getGroupClient, c)
}
func (u *User) GetUsersOnlineStatus(c *gin.Context) {
a2r.Call(user.UserClient.GetUsersOnlineStatus, u.getGroupClient, c)
}
func (u *User) GetUsersInfoFromCache(c *gin.Context) {
a2r.Call(user.UserClient.GetUsersInfoFromCache, u.getGroupClient, c)
}
func (u *User) GetFriendIDListFromCache(c *gin.Context) {
a2r.Call(user.UserClient.GetFriendIDListFromCache, u.getGroupClient, c)
}
func (u *User) GetBlackIDListFromCache(c *gin.Context) {
a2r.Call(user.UserClient.GetBlackIDListFromCache, u.getGroupClient, c)
}
//func (u *User) GetAllUsersUid(c *gin.Context) {
// a2r.Call(user.UserClient.GetAllUsersUid, u.getGroupClient, c)
//}
//
//func (u *User) AccountCheck(c *gin.Context) {
// a2r.Call(user.UserClient.AccountCheck, u.getGroupClient, c)
//}
func (u *User) GetUsers(c *gin.Context) {
a2r.Call(user.UserClient.GetPaginationUsers, u.getGroupClient, c)
}

513
internal/api/user/user.go
View File

@ -1,513 +0,0 @@
package user
import (
api "OpenIM/pkg/apistruct"
"OpenIM/pkg/common/config"
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/log"
"OpenIM/pkg/common/tokenverify"
pbRelay "OpenIM/pkg/proto/relay"
sdkws "OpenIM/pkg/proto/sdkws"
rpc "OpenIM/pkg/proto/user"
"OpenIM/pkg/utils"
jsonData "OpenIM/pkg/utils"
"context"
"net/http"
"strings"
"github.com/gin-gonic/gin"
)
func GetUsersInfoFromCache(c *gin.Context) {
params := api.GetUsersInfoReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
return
}
log.NewInfo(params.OperationID, "GetUsersInfoFromCache req: ", params)
req := &rpc.GetUserInfoReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
RpcResp, err := client.GetUserInfo(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
}
var publicUserInfoList []*sdkws.PublicUserInfo
for _, v := range RpcResp.UserInfoList {
publicUserInfoList = append(publicUserInfoList,
&sdkws.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
}
resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
resp.Data = jsonData.JsonDataList(resp.UserInfoList)
log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
c.JSON(http.StatusOK, resp)
}
func GetFriendIDListFromCache(c *gin.Context) {
var (
req api.GetFriendIDListFromCacheReq
resp api.GetFriendIDListFromCacheResp
reqPb cacheRpc.GetFriendIDListFromCacheReq
respPb *cacheRpc.GetFriendIDListFromCacheResp
)
if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req)
reqPb.OperationID = req.OperationID
var ok bool
var errInfo string
ok, reqPb.UserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := cacheRpc.NewCacheClient(etcdConn)
respPb, err := client.GetFriendIDListFromCache(context.Background(), &reqPb)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed:" + err.Error()})
return
}
resp.UserIDList = respPb.UserIDList
resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode}
c.JSON(http.StatusOK, resp)
}
func GetBlackIDListFromCache(c *gin.Context) {
var (
req api.GetBlackIDListFromCacheReq
resp api.GetBlackIDListFromCacheResp
reqPb cacheRpc.GetBlackIDListFromCacheReq
respPb *cacheRpc.GetBlackIDListFromCacheResp
)
if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
return
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req)
reqPb.OperationID = req.OperationID
var ok bool
var errInfo string
ok, reqPb.UserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImCacheName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := cacheRpc.NewCacheClient(etcdConn)
respPb, err := client.GetBlackIDListFromCache(context.Background(), &reqPb)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetFriendIDListFromCache", err.Error())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed:" + err.Error()})
return
}
resp.UserIDList = respPb.UserIDList
resp.CommResp = api.CommResp{ErrMsg: respPb.CommonResp.ErrMsg, ErrCode: respPb.CommonResp.ErrCode}
c.JSON(http.StatusOK, resp)
}
// @Summary 获取用户信息
// @Description 根据用户列表批量获取用户信息
// @Tags 用户相关
// @ID GetUsersInfo
// @Accept json
// @Param token header string true "im token"
// @Param req body api.GetUsersInfoReq true "请求体"
// @Produce json
// @Success 0 {object} api.GetUsersInfoResp{Map=[]sdkws.PublicUserInfo}
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /user/get_users_info [post]
func GetUsersPublicInfo(c *gin.Context) {
params := api.GetUsersInfoReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusOK, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()})
return
}
req := &rpc.GetUserInfoReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
RpcResp, err := client.GetUserInfo(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
}
var publicUserInfoList []*sdkws.PublicUserInfo
for _, v := range RpcResp.UserInfoList {
publicUserInfoList = append(publicUserInfoList,
&sdkws.PublicUserInfo{UserID: v.UserID, Nickname: v.Nickname, FaceURL: v.FaceURL, Gender: v.Gender, Ex: v.Ex})
}
resp := api.GetUsersInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfoList: publicUserInfoList}
resp.Data = jsonData.JsonDataList(resp.UserInfoList)
log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 修改用户信息
// @Description 修改用户信息 userID faceURL等
// @Tags 用户相关
// @ID UpdateUserInfo
// @Accept json
// @Param token header string true "im token"
// @Param req body api.UpdateSelfUserInfoReq true "请求体"
// @Produce json
// @Success 0 {object} api.UpdateUserInfoResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /user/update_user_info [post]
func UpdateUserInfo(c *gin.Context) {
params := api.UpdateSelfUserInfoReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
req := &rpc.UpdateUserInfoReq{UserInfo: &sdkws.UserInfo{}}
utils.CopyStructFields(req.UserInfo, &params)
req.OperationID = params.OperationID
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(params.OperationID, "UpdateUserInfo args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
RpcResp, err := client.UpdateUserInfo(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "UpdateUserInfo failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
}
resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
log.NewInfo(req.OperationID, "UpdateUserInfo api return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 设置全局免打扰
// @Description 设置全局免打扰
// @Tags 用户相关
// @ID SetGlobalRecvMessageOpt
// @Accept json
// @Param token header string true "im token"
// @Param req body api.SetGlobalRecvMessageOptReq true "globalRecvMsgOpt为全局免打扰设置0为关闭 1为开启"
// @Produce json
// @Success 0 {object} api.SetGlobalRecvMessageOptResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /user/set_global_msg_recv_opt [post]
func SetGlobalRecvMessageOpt(c *gin.Context) {
params := api.SetGlobalRecvMessageOptReq{}
if err := c.BindJSON(&params); err != nil {
log.NewError("0", "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
req := &rpc.SetGlobalRecvMessageOptReq{}
utils.CopyStructFields(req, &params)
req.OperationID = params.OperationID
var ok bool
var errInfo string
ok, req.UserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(params.OperationID, "SetGlobalRecvMessageOpt args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
RpcResp, err := client.SetGlobalRecvMessageOpt(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "SetGlobalRecvMessageOpt failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
}
resp := api.UpdateUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}}
log.NewInfo(req.OperationID, "SetGlobalRecvMessageOpt api return ", resp)
c.JSON(http.StatusOK, resp)
}
// @Summary 获取自己的信息
// @Description 传入ID获取自己的信息
// @Tags 用户相关
// @ID GetSelfUserInfo
// @Accept json
// @Param token header string true "im token"
// @Param req body api.GetSelfUserInfoReq true "请求体"
// @Produce json
// @Success 0 {object} api.GetSelfUserInfoResp{data=sdkws.UserInfo}
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /user/get_self_user_info [post]
func GetSelfUserInfo(c *gin.Context) {
params := api.GetSelfUserInfoReq{}
if err := c.BindJSON(&params); err != nil {
errMsg := " BindJSON failed " + err.Error()
log.NewError("0", errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 1001, "errMsg": errMsg})
return
}
req := &rpc.GetUserInfoReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(params.OperationID, errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 1001, "errMsg": errMsg})
return
}
req.UserIDList = append(req.UserIDList, params.UserID)
log.NewInfo(params.OperationID, "GetUserInfo args ", req.String())
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, req.OperationID)
if etcdConn == nil {
errMsg := req.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
RpcResp, err := client.GetUserInfo(context.Background(), req)
if err != nil {
log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
}
if len(RpcResp.UserInfoList) == 1 {
resp := api.GetSelfUserInfoResp{CommResp: api.CommResp{ErrCode: RpcResp.CommonResp.ErrCode, ErrMsg: RpcResp.CommonResp.ErrMsg}, UserInfo: RpcResp.UserInfoList[0]}
resp.Data = jsonData.JsonDataOne(resp.UserInfo)
log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
c.JSON(http.StatusOK, resp)
} else {
resp := api.GetSelfUserInfoResp{CommResp: api.CommResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}
log.NewInfo(req.OperationID, "GetUserInfo api return ", resp)
c.JSON(http.StatusOK, resp)
}
}
// @Summary 获取用户在线状态
// @Description 获取用户在线状态
// @Tags 用户相关
// @ID GetUsersOnlineStatus
// @Accept json
// @Param token header string true "im token"
// @Param req body api.GetUsersOnlineStatusReq true "请求体"
// @Produce json
// @Success 0 {object} api.GetUsersOnlineStatusResp
// @Failure 500 {object} api.Swagger500Resp "errCode为500 一般为服务器内部错误"
// @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
// @Router /user/get_users_online_status [post]
func GetUsersOnlineStatus(c *gin.Context) {
params := api.GetUsersOnlineStatusReq{}
if err := c.BindJSON(&params); err != nil {
c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
req := &pbRelay.GetUsersOnlineStatusReq{}
utils.CopyStructFields(req, &params)
var ok bool
var errInfo string
ok, req.OpUserID, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusOK, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
if len(config.Config.Manager.AppManagerUid) == 0 {
log.NewError(req.OperationID, "Manager == 0")
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "Manager == 0"})
return
}
req.OpUserID = config.Config.Manager.AppManagerUid[0]
log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
flag := false
grpcCons := rpc.GetDefaultGatewayConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), params.OperationID)
for _, v := range grpcCons {
log.Debug(params.OperationID, "get node ", *v, v.Target())
client := pbRelay.NewRelayClient(v)
reply, err := client.GetUsersOnlineStatus(context.Background(), req)
if err != nil {
log.NewError(params.OperationID, "GetUsersOnlineStatus rpc err", req.String(), err.Error())
continue
} else {
if reply.ErrCode == 0 {
wsResult = append(wsResult, reply.SuccessResult...)
}
}
}
log.NewInfo(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult)
//Online data merge of each node
for _, v1 := range params.UserIDList {
flag = false
temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
for _, v2 := range wsResult {
if v2.UserID == v1 {
flag = true
temp.UserID = v1
temp.Status = constant.OnlineStatus
temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...)
}
}
if !flag {
temp.UserID = v1
temp.Status = constant.OfflineStatus
}
respResult = append(respResult, temp)
}
resp := api.GetUsersOnlineStatusResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, SuccessResult: respResult}
if len(respResult) == 0 {
resp.SuccessResult = []*pbRelay.GetUsersOnlineStatusResp_SuccessResult{}
}
log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
c.JSON(http.StatusOK, resp)
}
func GetUsers(c *gin.Context) {
var (
req api.GetUsersReq
resp api.GetUsersResp
reqPb rpc.GetUsersReq
)
if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "Bind failed ", err.Error(), req)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return
}
var ok bool
var errInfo string
ok, _, errInfo = tokenverify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
if !ok {
errMsg := req.OperationID + " " + "GetUserIDFromToken failed " + errInfo + " token:" + c.Request.Header.Get("token")
log.NewError(req.OperationID, errMsg)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
reqPb.OperationID = req.OperationID
reqPb.UserID = req.UserID
reqPb.UserName = req.UserName
reqPb.Content = req.Content
reqPb.Pagination = &sdkws.RequestPagination{ShowNumber: req.ShowNumber, PageNumber: req.PageNumber}
etcdConn := rpc.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName, reqPb.OperationID)
if etcdConn == nil {
errMsg := reqPb.OperationID + "getcdv3.GetDefaultConn == nil"
log.NewError(reqPb.OperationID, errMsg)
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
return
}
client := rpc.NewUserClient(etcdConn)
respPb, err := client.GetUsers(context.Background(), &reqPb)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), reqPb.String())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": err.Error()})
return
}
for _, v := range respPb.UserList {
user := api.CMSUser{}
utils.CopyStructFields(&user, v.User)
user.IsBlock = v.IsBlock
resp.Data.UserList = append(resp.Data.UserList, &user)
}
resp.CommResp.ErrCode = respPb.CommonResp.ErrCode
resp.CommResp.ErrMsg = respPb.CommonResp.ErrMsg
resp.Data.TotalNum = respPb.TotalNums
resp.Data.CurrentPage = respPb.Pagination.CurrentPage
resp.Data.ShowNumber = respPb.Pagination.ShowNumber
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp)
c.JSON(http.StatusOK, resp)
return
}

99
internal/api2rpc/api.go
View File

@ -1,99 +0,0 @@
package api2rpc
import (
"OpenIM/pkg/common/constant"
"OpenIM/pkg/common/tracelog"
"context"
"fmt"
"github.com/gin-gonic/gin"
"google.golang.org/grpc/status"
"net/http"
"strings"
)
//func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcClientFunc interface{}, rpcFuncName string) {
// if rpcName == "" {
// rpcName = utils2.GetFuncName(1)
// }
// logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
// ctx := tracelog.NewCtx(c, rpcFuncName)
// defer log.ShowLog(ctx)
// if err := c.BindJSON(apiReq); err != nil {
// WriteErrorResponse(ctx, "BindJSON", err)
// return
// }
// tracelog.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
// etcdConn, err := rpcFn.GetConn(ctx, rpcName)
// if err != nil {
// WriteErrorResponse(ctx, "GetConn", err)
// return
// }
// rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
// reflect.ValueOf(etcdConn),
// })[0].MethodByName(rpcFuncName) // rpcClient func
// rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req
// CopyAny(apiReq, rpcReqPtr.Interface())
// tracelog.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
// respArr := rpcClient.Call([]reflect.Value{
// reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID)
// rpcReqPtr, // rpcClient apiReq
// }) // respArr => (apiResp, error)
// if !respArr[1].IsNil() { // rpcClient err != nil
// err := respArr[1].Interface().(error)
// WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
// return
// }
// rpcResp := respArr[0].Elem()
// tracelog.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
// if apiResp != nil {
// CopyAny(rpcResp.Interface(), apiResp)
// }
// SetSuccess(ctx, rpcFuncName, apiResp)
//}
func rpcString(v interface{}) string {
if s, ok := v.(interface{ String() string }); ok {
return s.String()
}
return fmt.Sprintf("%+v", v)
}
type baseResp struct {
ErrCode int32 `json:"errCode"`
ErrMsg string `json:"errMsg"`
ErrDtl string `json:"errDtl"`
Data interface{} `json:"data"`
}
func WriteErrorResponse(ctx context.Context, funcName string, err error, args ...interface{}) {
tracelog.SetCtxInfo(ctx, funcName, err, args)
e := tracelog.Unwrap(err)
switch t := e.(type) {
case *constant.ErrInfo:
ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo).GinCtx.JSON(http.StatusOK, baseResp{ErrCode: t.ErrCode, ErrMsg: t.ErrMsg, ErrDtl: t.DetailErrMsg})
//ctx.Value(TraceLogKey).(*ApiInfo).GinCtx.JSON(http.StatusOK, gin.H{"errCode": t.ErrCode, "errMsg": t.ErrMsg, "errDtl": t.DetailErrMsg})
return
default:
s, ok := status.FromError(e)
if !ok {
ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo).GinCtx.JSON(http.StatusOK, &baseResp{ErrCode: constant.ErrDefaultOther.ErrCode, ErrMsg: err.Error(), ErrDtl: fmt.Sprintf("%+v", err)})
//ctx.Value(TraceLogKey).(*ApiInfo).GinCtx.JSON(http.StatusOK, gin.H{"errCode": constant.ErrDefaultOther.ErrCode, "errMsg": err.Error(), "errDtl": fmt.Sprintf("%+v", err)})
return
}
var details []string
if err != e {
details = append(details, fmt.Sprintf("%+v", err))
}
for _, s := range s.Details() {
details = append(details, fmt.Sprintf("%+v", s))
}
ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo).GinCtx.JSON(http.StatusOK, &baseResp{ErrCode: int32(s.Code()), ErrMsg: s.Message(), ErrDtl: strings.Join(details, "\n")})
//ctx.Value(TraceLogKey).(*ApiInfo).GinCtx.JSON(http.StatusOK, gin.H{"errCode": s.Code(), "errMsg": s.Message(), "errDtl": strings.Join(details, "\n")})
return
}
}
func SetSuccess(ctx context.Context, funcName string, data interface{}) {
tracelog.SetCtxInfo(ctx, funcName, nil, "data", data)
ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo).GinCtx.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "errDtl": "", "data": data})
}

23
internal/api2rpc/api2rpc.go
View File

@ -1,23 +0,0 @@
package api2rpc
import (
"context"
)
type Ignore struct{}
type ApiBind[A, B any] interface {
OperationID() string
OpUserID() (string, error)
Bind(*A) error
Context() context.Context
Resp(resp *B, err error)
}
type Api interface {
OperationID() string
OpUserID() string
Context() context.Context
Bind(req any) error
Resp(resp any, err error)
}

1
internal/api2rpc/api2rpc_test.go
View File

@ -1 +0,0 @@
package api2rpc

274
internal/api2rpc/copy.go
View File

@ -1,274 +0,0 @@
package api2rpc
import (
"fmt"
"google.golang.org/protobuf/types/known/wrapperspb"
"reflect"
)
func CopyAny(from, to interface{}) {
copyAny(reflect.ValueOf(from), reflect.Indirect(reflect.ValueOf(to)))
}
func copyAny(from, to reflect.Value) {
if !to.CanSet() {
return
}
if isBaseNil(from) {
return
}
if isBaseNil(to) {
to.Set(getBaseZeroValue(to.Type()))
}
btFrom := baseType(from.Type())
btTo := baseType(to.Type())
if btTo.Kind() == reflect.Interface || typeEq(btFrom, btTo) {
setBaseValue(from, to)
return
}
if _, ok := wrapType[btTo.String()]; ok { // string -> wrapperspb.StringValue
val := reflect.New(btTo).Elem()
copyAny(from, val.FieldByName("Value"))
setBaseValue(val, to)
return
}
if _, ok := wrapType[btFrom.String()]; ok { // wrapperspb.StringValue -> string
copyAny(baseValue(from).FieldByName("Value"), to)
return
}
if btFrom.Kind() == reflect.Struct && btTo.Kind() == reflect.Struct {
copyStruct(baseValue(from), baseValue(to))
return
}
if btFrom.Kind() == reflect.Slice && btTo.Kind() == reflect.Slice {
copySlice(baseValue(from), baseValue(to))
return
}
if btFrom.Kind() == reflect.Map && btTo.Kind() == reflect.Map {
copyMap(baseValue(from), baseValue(to))
return
}
if btTo.Kind() == reflect.String {
if isBaseNil(to) {
to.Set(getBaseZeroValue(baseType(to.Type())))
}
setBaseValue(reflect.ValueOf(toString(from)), to)
return
}
if toNumber(from, to) {
return
}
}
func setBaseValue(from, to reflect.Value) {
if isBaseNil(from) {
return
}
var l int
t := to.Type()
for t.Kind() == reflect.Ptr {
l++
t = t.Elem()
}
v := baseValue(from)
for i := 0; i < l; i++ {
t := reflect.New(v.Type())
t.Elem().Set(v)
v = t
}
to.Set(v)
}
func getBaseZeroValue(t reflect.Type) reflect.Value {
var l int
for t.Kind() == reflect.Ptr {
l++
t = t.Elem()
}
v := reflect.New(t)
if l == 0 {
v = v.Elem()
} else {
for i := 1; i < l; i++ {
t := reflect.New(v.Type())
t.Elem().Set(v)
v = t
}
}
r := reflect.New(v.Type()).Elem()
r.Set(v)
return r
}
func isBaseNil(v reflect.Value) bool {
for {
switch v.Kind() {
case reflect.Ptr:
v = v.Elem()
case reflect.Invalid:
return true
default:
return isNil(v)
}
}
}
func baseType(t reflect.Type) reflect.Type {
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t
}
func typeEq(t1, t2 reflect.Type) bool {
return t1.String() == t2.String()
}
func isNil(value reflect.Value) bool {
switch value.Kind() {
case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.UnsafePointer, reflect.Interface, reflect.Slice:
return value.IsNil()
}
return false
}
func baseValue(value reflect.Value) reflect.Value {
for value.Kind() == reflect.Ptr {
value = value.Elem()
}
return value
}
func copyStruct(from, to reflect.Value) {
toType := to.Type()
fromType := from.Type()
n := to.NumField()
for i := 0; i < n; i++ {
toFieldType := toType.Field(i)
if _, found := fromType.FieldByName(toFieldType.Name); !found {
continue
}
copyAny(from.FieldByName(toFieldType.Name), to.Field(i))
}
}
func copySlice(from, to reflect.Value) {
size := from.Len()
temp := reflect.MakeSlice(to.Type(), 0, size)
elemTo := to.Type().Elem()
for i := 0; i < size; i++ {
var itemTo reflect.Value
if item := from.Index(i); isBaseNil(item) {
itemTo = reflect.Zero(elemTo)
} else {
itemTo = getBaseZeroValue(elemTo)
copyAny(from.Index(i), itemTo)
}
temp = reflect.Append(temp, itemTo)
}
to.Set(temp)
}
func copyMap(from, to reflect.Value) {
to.Set(reflect.MakeMap(to.Type()))
toTypeKey := to.Type().Key()
toTypeVal := to.Type().Elem()
for r := from.MapRange(); r.Next(); {
key := getBaseZeroValue(toTypeKey)
copyAny(r.Key(), key)
var val reflect.Value
fVal := r.Value()
if isBaseNil(fVal) {
val = reflect.Zero(toTypeVal)
} else {
val = getBaseZeroValue(toTypeVal)
copyAny(fVal, val)
}
to.SetMapIndex(key, val)
}
}
func toString(value reflect.Value) string {
if value.Kind() == reflect.Slice {
switch value.Type().String() {
case "[]uint8": // []byte -> []uint8
return string(value.Interface().([]uint8))
case "[]int32": // []rune -> []int32
return string(value.Interface().([]int32))
}
}
return fmt.Sprint(value.Interface())
}
func toNumber(from, to reflect.Value) bool {
initTo := func() {
if isBaseNil(to) {
to.Set(getBaseZeroValue(to.Type()))
}
}
switch baseValue(from).Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch baseValue(to).Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
initTo()
baseValue(to).SetInt(baseValue(from).Int())
return true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
initTo()
baseValue(to).SetUint(uint64(baseValue(from).Int()))
return true
case reflect.Float64, reflect.Float32:
initTo()
baseValue(to).SetFloat(float64(baseValue(from).Int()))
return true
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
switch baseValue(to).Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
initTo()
baseValue(to).SetInt(int64(baseValue(from).Uint()))
return true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
initTo()
baseValue(to).SetInt(int64(baseValue(from).Uint()))
return true
case reflect.Float64, reflect.Float32:
initTo()
baseValue(to).SetFloat(float64(baseValue(from).Uint()))
return true
}
case reflect.Float64, reflect.Float32:
switch baseValue(to).Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
initTo()
baseValue(to).SetInt(int64(baseValue(from).Float()))
return true
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
initTo()
baseValue(to).SetUint(uint64(baseValue(from).Float()))
return true
case reflect.Float64, reflect.Float32:
initTo()
baseValue(to).SetFloat(baseValue(from).Float())
return true
}
}
return false
}
func typeName(v interface{}) string {
return reflect.TypeOf(v).String()
}
var wrapType = map[string]struct{}{
typeName(wrapperspb.DoubleValue{}): {},
typeName(wrapperspb.FloatValue{}): {},
typeName(wrapperspb.Int64Value{}): {},
typeName(wrapperspb.UInt64Value{}): {},
typeName(wrapperspb.Int32Value{}): {},
typeName(wrapperspb.UInt32Value{}): {},
typeName(wrapperspb.BoolValue{}): {},
typeName(wrapperspb.StringValue{}): {},
typeName(wrapperspb.BytesValue{}): {},
}

98
internal/api2rpc/gin.go
View File

@ -1,98 +0,0 @@
package api2rpc
import (
"context"
"github.com/gin-gonic/gin"
)
//func KickGroupMember(c *gin.Context) {
// // 默认 全部自动
// //var api ApiBind[apistruct.KickGroupMemberReq, apistruct.KickGroupMemberResp] = NewGin[apistruct.KickGroupMemberReq, apistruct.KickGroupMemberResp](c)
// var api ApiBind[apistruct.KickGroupMemberReq, apistruct.KickGroupMemberResp] = nil
// var client func(conn *grpc.ClientConn) group.GroupClient = nil
// var rpcFn func(ctx context.Context, in *group.KickGroupMemberReq, opts ...grpc.CallOption) (*group.KickGroupMemberResp, error) = nil
// //NewRpc(api, client, rpcFn).Name("group").Call()
// NewRpc(api, client, rpcFn).Name("group").Call()
//
// // 可以自定义编辑请求和响应
// //a := NewRpc(NewGin[apistruct.KickGroupMemberReq, apistruct.KickGroupMemberResp](c), "", group.NewGroupClient, group.GroupClient.KickGroupMember)
// //a.Before(func(apiReq *apistruct.KickGroupMemberReq, rpcReq *group.KickGroupMemberReq, bind func() error) error {
// // return bind()
// //}).After(func(rpcResp *group.KickGroupMemberResp, apiResp *apistruct.KickGroupMemberResp, bind func() error) error {
// // return bind()
// //}).Execute()
//}
//
func NewGin[A, B any](c *gin.Context) ApiBind[A, B] {
return &ginApiBind[A, B]{
c: c,
}
}
type ginApiBind[A, B any] struct {
c *gin.Context
}
func (g *ginApiBind[A, B]) OperationID() string {
return g.c.GetHeader("operationID")
}
func (g *ginApiBind[A, B]) OpUserID() (string, error) {
return "", nil
}
func (g *ginApiBind[A, B]) Bind(a *A) error {
return g.c.BindJSON(a)
}
func (g *ginApiBind[A, B]) Resp(resp *B, err error) {
if err == nil {
g.Write(resp)
} else {
g.Error(err)
}
}
func (g *ginApiBind[A, B]) Error(err error) {
//TODO implement me
}
func (g *ginApiBind[A, B]) Write(b *B) {
//TODO implement me
}
func (g *ginApiBind[A, B]) Context() context.Context {
return g.c
}
func NewGin1(c *gin.Context) Api {
return &ginApi{
c: c,
}
}
type ginApi struct {
c *gin.Context
}
func (g *ginApi) OperationID() string {
return g.c.GetHeader("operationID")
}
func (g *ginApi) OpUserID() string {
return g.c.MustGet("opUserID").(string)
}
func (g *ginApi) Context() context.Context {
return g.c
}
func (g *ginApi) Bind(req any) error {
return g.c.BindJSON(req)
}
func (g *ginApi) Resp(resp any, err error) {
//TODO implement me
panic("implement me")
}

114
internal/api2rpc/rpc.go
View File

@ -1,114 +0,0 @@
package api2rpc
import (
"context"
"google.golang.org/grpc"
"reflect"
)
var nameMap = map[string]string{}
func getName[T any]() string {
var t T
return reflect.TypeOf(&t).Elem().Name()
}
// NewRpc A: apiReq B: apiResp C: rpcReq D: rpcResp Z: rpcClient (group.GroupClient)
func NewRpc[A, B any, C, D any, Z any](bind ApiBind[A, B], client func(conn *grpc.ClientConn) Z, rpc func(client Z, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)) *RpcXXXX[A, B, C, D, Z] {
return &RpcXXXX[A, B, C, D, Z]{
bind: bind,
client: client,
rpc: rpc,
}
}
type RpcXXXX[A, B any, C, D any, Z any] struct {
bind ApiBind[A, B]
name string
client func(conn *grpc.ClientConn) Z
rpc func(client Z, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)
before func(apiReq *A, rpcReq *C, bind func() error) error
after func(rpcResp *D, apiResp *B, bind func() error) error
}
func (a *RpcXXXX[A, B, C, D, Z]) Name(name string) *RpcXXXX[A, B, C, D, Z] {
a.name = name
return a
}
func (a *RpcXXXX[A, B, C, D, Z]) Before(fn func(apiReq *A, rpcReq *C, bind func() error) error) *RpcXXXX[A, B, C, D, Z] {
a.before = fn
return a
}
func (a *RpcXXXX[A, B, C, D, Z]) After(fn func(rpcResp *D, apiResp *B, bind func() error) error) *RpcXXXX[A, B, C, D, Z] {
a.after = fn
return a
}
func (a *RpcXXXX[A, B, C, D, Z]) defaultCopyReq(apiReq *A, rpcReq *C) error {
CopyAny(apiReq, rpcReq)
return nil
}
func (a *RpcXXXX[A, B, C, D, Z]) defaultCopyResp(rpcResp *D, apiResp *B) error {
CopyAny(rpcResp, apiResp)
return nil
}
func (a *RpcXXXX[A, B, C, D, Z]) getZtype() string {
return ""
}
func (a *RpcXXXX[A, B, C, D, Z]) GetGrpcConn() (*grpc.ClientConn, error) {
if a.name == "" {
a.name = nameMap[getName[Z]()]
}
// todo 获取连接
return nil, nil // todo
}
func (a *RpcXXXX[A, B, C, D, Z]) execute() (*B, error) {
var apiReq A
if err := a.bind.Bind(&apiReq); err != nil {
return nil, err
}
opID := a.bind.OperationID()
userID, err := a.bind.OpUserID()
if err != nil {
return nil, err
}
_, _ = opID, userID
var rpcReq C
if a.before == nil {
err = a.defaultCopyReq(&apiReq, &rpcReq)
} else {
err = a.before(&apiReq, &rpcReq, func() error { return a.defaultCopyReq(&apiReq, &rpcReq) })
}
if err != nil {
return nil, err
}
conn, err := a.GetGrpcConn()
if err != nil {
return nil, err
}
rpcResp, err := a.rpc(a.client(conn), a.bind.Context(), &rpcReq)
if err != nil {
return nil, err
}
var apiResp B
if a.after == nil {
err = a.defaultCopyResp(rpcResp, &apiResp)
} else {
err = a.after(rpcResp, &apiResp, func() error { return a.defaultCopyResp(rpcResp, &apiResp) })
}
if err != nil {
return nil, err
}
return &apiResp, nil
}
func (a *RpcXXXX[A, B, C, D, Z]) Call() {
a.bind.Resp(a.execute())
}

98
internal/api2rpc/rpc1.go
View File

@ -1,98 +0,0 @@
package api2rpc
import (
"context"
"github.com/gin-gonic/gin"
"google.golang.org/grpc"
)
type rpcFunc[E, C, D any] func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)
func Rpc[A, B, C, D any, E any](apiReq *A, apiResp *B, rpc func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)) RpcCall[A, B, C, D, E] {
return &rpcCall[A, B, C, D, E]{
apiReq: apiReq,
apiResp: apiResp,
rpcFn: rpc,
}
}
type rpcCall[A, B, C, D any, E any] struct {
apiReq *A
apiResp *B
client func() (E, error)
rpcFn func(client E, ctx context.Context, req *C, options ...grpc.CallOption) (*D, error)
api Api
before func(apiReq *A, rpcReq *C, bind func() error) error
after func(rpcResp *D, apiResp *B, bind func() error) error
}
func (r *rpcCall[A, B, C, D, E]) Before(fn func(apiReq *A, rpcReq *C, bind func() error) error) RpcCall[A, B, C, D, E] {
r.before = fn
return r
}
func (r *rpcCall[A, B, C, D, E]) After(fn func(rpcResp *D, apiResp *B, bind func() error) error) RpcCall[A, B, C, D, E] {
r.after = fn
return r
}
func (r *rpcCall[A, B, C, D, E]) Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E] {
r.api = NewGin1(c)
r.client = client
return r
}
func (r *rpcCall[A, B, C, D, E]) Call() {
r.api.Resp(r.apiResp, r.call())
}
func (r *rpcCall[A, B, C, D, E]) defaultCopyReq(rpcReq *C) error {
if r.apiReq != nil {
CopyAny(r.apiReq, rpcReq)
}
return nil
}
func (r *rpcCall[A, B, C, D, E]) defaultCopyResp(rpcResp *D) error {
if r.apiResp != nil {
CopyAny(rpcResp, r.apiResp)
}
return nil
}
func (r *rpcCall[A, B, C, D, E]) call() error {
if err := r.api.Bind(r.apiReq); err != nil {
return err
}
var err error
var rpcReq C
if r.before == nil {
err = r.defaultCopyReq(&rpcReq)
} else {
err = r.before(r.apiReq, &rpcReq, func() error { return r.defaultCopyReq(&rpcReq) })
}
if err != nil {
return err
}
client, err := r.client()
if err != nil {
return err
}
rpcResp, err := r.rpcFn(client, r.api.Context(), &rpcReq)
if err != nil {
return err
}
var apiResp B
if r.after == nil {
return r.defaultCopyResp(rpcResp)
} else {
return r.after(rpcResp, &apiResp, func() error { return r.defaultCopyResp(rpcResp) })
}
}
type RpcCall[A, B, C, D, E any] interface {
Before(fn func(apiReq *A, rpcReq *C, bind func() error) error) RpcCall[A, B, C, D, E]
After(fn func(rpcResp *D, apiResp *B, bind func() error) error) RpcCall[A, B, C, D, E]
Must(c *gin.Context, client func() (E, error)) RpcCall[A, B, C, D, E]
Call()
}

18
internal/apiresp/resp.go Normal file
View File

@ -0,0 +1,18 @@
package apiresp
type ApiResponse struct {
ErrCode int `json:"errCode"`
ErrMsg string `json:"errMsg"`
ErrDlt string `json:"errDlt"`
Data any `json:"data"`
}
func Success(data any) *ApiResponse {
return &ApiResponse{
Data: data,
}
}
func Error(err error) *ApiResponse {
return &ApiResponse{}
}

11679
pkg/proto/group/group.pb.go
View File

File diff suppressed because it is too large Load Diff

2
pkg/utils/utils_v2_test.go
View File

@ -39,7 +39,7 @@ func TestSliceToMap(t *testing.T) {
func TestIndexOf(t *testing.T) {
arr := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Println(IndexOf(arr, 3))
fmt.Println(IndexOf(3, arr...))
}