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

api

Browse Source
This commit is contained in:
withchao 2023-02-28 11:38:05 +08:00
parent e30e391756
commit 1538917089
5 changed files with 175 additions and 1475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,233 +1,44 @@
package apiAuth
import (
api "OpenIM/pkg/apistruct"
"OpenIM/internal/a2r"
"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"
auth "OpenIM/pkg/proto/auth"
"context"
"net/http"
"strings"
"github.com/fatih/structs"
"github.com/OpenIMSDK/openKeeper"
"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)
var _ context.Context // 解决goland编辑器bug
func NewAuth(zk *openKeeper.ZkClient) *Auth {
return &Auth{zk: zk}
}
// @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
}
type Auth struct {
zk *openKeeper.ZkClient
}
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)
func (a *Auth) getGroupClient() (auth.AuthClient, error) {
conn, err := a.zk.GetConn(config.Config.RpcRegisterName.OpenImGroupName)
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
return nil, err
}
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)
return auth.NewAuthClient(conn), nil
}
// @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)
func (a *Auth) UserRegister(c *gin.Context) {
a2r.Call(auth.AuthClient.UserRegister, a.getGroupClient, c)
}
// @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)
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)
}

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

@ -1,678 +1,76 @@
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)
//}
import (
"OpenIM/internal/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)
}

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, "")
}

73
internal/api/route.go
View File

@ -13,7 +13,6 @@ import (
"OpenIM/pkg/common/log"
"OpenIM/pkg/common/middleware"
"OpenIM/pkg/common/prome"
"OpenIM/pkg/common/tokenverify"
"github.com/gin-gonic/gin"
"io"
"os"
@ -35,52 +34,41 @@ 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 := user.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 := friend.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 := group.NewGroup(nil)
{
groupRouterGroup.POST("/create_group", g.NewCreateGroup) //1
@ -114,10 +102,11 @@ func NewGinRouter() *gin.Engine {
////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 := apiAuth.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")

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

@ -1,513 +1,72 @@
package user
import (
api "OpenIM/pkg/apistruct"
"OpenIM/internal/a2r"
"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"
"OpenIM/pkg/proto/user"
"context"
"net/http"
"strings"
"github.com/OpenIMSDK/openKeeper"
"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)
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 {
log.NewError(req.OperationID, "GetUserInfo failed ", err.Error(), req.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "call rpc server failed"})
return
return nil, err
}
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)
return user.NewUserClient(conn), nil
}
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 (u *User) UpdateUserInfo(c *gin.Context) {
a2r.Call(user.UserClient.UpdateUserInfo, u.getGroupClient, c)
}
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)
func (u *User) SetGlobalRecvMessageOpt(c *gin.Context) {
a2r.Call(user.UserClient.SetGlobalRecvMessageOpt, u.getGroupClient, c)
}
// @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)
func (u *User) GetUsersPublicInfo(c *gin.Context) {
a2r.Call(user.UserClient.GetDesignateUsers, u.getGroupClient, c)
}
// @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)
func (u *User) GetSelfUserInfo(c *gin.Context) {
a2r.Call(user.UserClient.GetSelfUserInfo, u.getGroupClient, c)
}
// @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)
func (u *User) GetUsersOnlineStatus(c *gin.Context) {
a2r.Call(user.UserClient.GetUsersOnlineStatus, u.getGroupClient, c)
}
// @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)
}
func (u *User) GetUsersInfoFromCache(c *gin.Context) {
a2r.Call(user.UserClient.GetUsersInfoFromCache, u.getGroupClient, c)
}
// @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 (u *User) GetFriendIDListFromCache(c *gin.Context) {
a2r.Call(user.UserClient.GetFriendIDListFromCache, u.getGroupClient, c)
}
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
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)
}