pull/351/head
wangchuxiao 3 years ago
parent da9918b655
commit 8d4e5ad3f1

@ -111,7 +111,6 @@ func main() {
groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname) groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname)
groupRouterGroup.POST("/set_group_member_info", group.SetGroupMemberInfo) groupRouterGroup.POST("/set_group_member_info", group.SetGroupMemberInfo)
groupRouterGroup.POST("/get_group_abstract_info", group.GetGroupAbstractInfo) groupRouterGroup.POST("/get_group_abstract_info", group.GetGroupAbstractInfo)
groupRouterGroup.POST("/get_groups", group.GetGroups)
//groupRouterGroup.POST("/get_group_all_member_list_by_split", group.GetGroupAllMemberListBySplit) //groupRouterGroup.POST("/get_group_all_member_list_by_split", group.GetGroupAllMemberListBySplit)
} }
superGroupRouterGroup := r.Group("/super_group") superGroupRouterGroup := r.Group("/super_group")

@ -11,6 +11,7 @@ import (
open_im_sdk "Open_IM/pkg/proto/sdk_ws" open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"github.com/golang/protobuf/ptypes/wrappers" "github.com/golang/protobuf/ptypes/wrappers"
"google.golang.org/grpc" "google.golang.org/grpc"
@ -1318,7 +1319,3 @@ func GetGroupAbstractInfo(c *gin.Context) {
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
return return
} }
func GetGroups(c *gin.Context) {
}

@ -463,7 +463,7 @@ func GetUsers(c *gin.Context) {
resp api.GetUsersResp resp api.GetUsersResp
reqPb rpc.GetUsersReq reqPb rpc.GetUsersReq
) )
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "Bind failed ", err.Error(), req) log.NewError(req.OperationID, "Bind failed ", err.Error(), req)
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return

@ -3,8 +3,6 @@ package group
import ( import (
"Open_IM/pkg/cms_api_struct" "Open_IM/pkg/cms_api_struct"
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
openIMHttp "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
commonPb "Open_IM/pkg/proto/sdk_ws" commonPb "Open_IM/pkg/proto/sdk_ws"
@ -18,51 +16,15 @@ import (
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
func GetGroupByID(c *gin.Context) {
var (
req cms_api_struct.GetGroupByIDRequest
resp cms_api_struct.GetGroupByIDResponse
reqPb pbGroup.GetGroupByIDReq
)
if err := c.ShouldBindQuery(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
reqPb.OperationID = utils.OperationIDGenerator()
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
reqPb.GroupID = req.GroupID
etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, 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 := pbGroup.NewGroupClient(etcdConn)
respPb, err := client.GetGroupByID(context.Background(), &reqPb)
if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById failed ", err.Error())
openIMHttp.RespHttp200(c, err, nil)
return
}
utils.CopyStructFields(&resp, respPb.CMSGroup.GroupInfo)
resp.GroupOwnerID = respPb.CMSGroup.GroupOwnerUserID
resp.GroupOwnerName = respPb.CMSGroup.GroupOwnerUserName
log.NewInfo("", utils.GetSelfFuncName(), "req: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp)
}
func GetGroups(c *gin.Context) { func GetGroups(c *gin.Context) {
var ( var (
req cms_api_struct.GetGroupsRequest req cms_api_struct.GetGroupsRequest
resp cms_api_struct.GetGroupsResponse resp cms_api_struct.GetGroupsResponse
reqPb pbGroup.GetGroupsReq reqPb pbGroup.GetGroupsReq
) )
if err := c.ShouldBindQuery(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -80,7 +42,7 @@ func GetGroups(c *gin.Context) {
respPb, err := client.GetGroups(context.Background(), &reqPb) respPb, err := client.GetGroups(context.Background(), &reqPb)
if err != nil { if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error())
openIMHttp.RespHttp200(c, err, nil) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
for _, v := range respPb.CMSGroups { for _, v := range respPb.CMSGroups {
@ -91,54 +53,10 @@ func GetGroups(c *gin.Context) {
resp.Groups = append(resp.Groups, groupResp) resp.Groups = append(resp.Groups, groupResp)
} }
resp.GroupNums = int(respPb.GroupNum) resp.GroupNums = int(respPb.GroupNum)
resp.CurrentPage = int(respPb.Pagination.PageNumber) resp.CurrentPage = int(respPb.Pagination.CurrentPage)
resp.ShowNumber = int(respPb.Pagination.ShowNumber)
log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp)
}
func GetGroupByName(c *gin.Context) {
var (
req cms_api_struct.GetGroupRequest
resp cms_api_struct.GetGroupResponse
reqPb pbGroup.GetGroupReq
)
if err := c.ShouldBindQuery(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
return
}
reqPb.OperationID = utils.OperationIDGenerator()
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", req)
reqPb.GroupName = req.GroupName
reqPb.Pagination = &commonPb.RequestPagination{}
utils.CopyStructFields(&reqPb.Pagination, req)
etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, 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 := pbGroup.NewGroupClient(etcdConn)
respPb, err := client.GetGroup(context.Background(), &reqPb)
if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroup failed", err.Error())
openIMHttp.RespHttp200(c, constant.ErrServer, nil)
return
}
for _, v := range respPb.CMSGroups {
groupResp := cms_api_struct.GroupResponse{}
utils.CopyStructFields(&groupResp, v.GroupInfo)
groupResp.GroupOwnerName = v.GroupOwnerUserName
groupResp.GroupOwnerID = v.GroupOwnerUserID
resp.Groups = append(resp.Groups, groupResp)
}
resp.CurrentPage = int(respPb.Pagination.PageNumber)
resp.ShowNumber = int(respPb.Pagination.ShowNumber) resp.ShowNumber = int(respPb.Pagination.ShowNumber)
resp.GroupNums = int(respPb.GroupNums)
log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp) log.NewInfo("", utils.GetSelfFuncName(), "resp: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg, "data": resp})
} }
func GetGroupMembers(c *gin.Context) { func GetGroupMembers(c *gin.Context) {
@ -147,9 +65,9 @@ func GetGroupMembers(c *gin.Context) {
reqPb pbGroup.GetGroupMembersCMSReq reqPb pbGroup.GetGroupMembersCMSReq
resp cms_api_struct.GetGroupMembersResponse resp cms_api_struct.GetGroupMembersResponse
) )
if err := c.ShouldBindQuery(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -171,7 +89,7 @@ func GetGroupMembers(c *gin.Context) {
respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb) respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
if err != nil { if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS failed:", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS failed:", err.Error())
openIMHttp.RespHttp200(c, err, nil) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
resp.ResponsePagination = cms_api_struct.ResponsePagination{ resp.ResponsePagination = cms_api_struct.ResponsePagination{
@ -185,5 +103,5 @@ func GetGroupMembers(c *gin.Context) {
resp.GroupMembers = append(resp.GroupMembers, memberResp) resp.GroupMembers = append(resp.GroupMembers, memberResp)
} }
log.NewInfo("", utils.GetSelfFuncName(), "req: ", resp) log.NewInfo("", utils.GetSelfFuncName(), "req: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg, "data": resp})
} }

@ -3,7 +3,6 @@ package messageCMS
import ( import (
"Open_IM/pkg/cms_api_struct" "Open_IM/pkg/cms_api_struct"
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
openIMHttp "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
pbAdminCMS "Open_IM/pkg/proto/admin_cms" pbAdminCMS "Open_IM/pkg/proto/admin_cms"
@ -13,8 +12,6 @@ import (
"net/http" "net/http"
"strings" "strings"
"Open_IM/pkg/common/constant"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
@ -24,9 +21,9 @@ func GetChatLogs(c *gin.Context) {
resp cms_api_struct.GetChatLogsResp resp cms_api_struct.GetChatLogsResp
reqPb pbAdminCMS.GetChatLogsReq reqPb pbAdminCMS.GetChatLogsReq
) )
if err := c.ShouldBindQuery(&req); err != nil { if err := c.Bind(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, resp) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
reqPb.Pagination = &pbCommon.RequestPagination{ reqPb.Pagination = &pbCommon.RequestPagination{
@ -46,7 +43,7 @@ func GetChatLogs(c *gin.Context) {
respPb, err := client.GetChatLogs(context.Background(), &reqPb) respPb, err := client.GetChatLogs(context.Background(), &reqPb)
if err != nil { if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error())
openIMHttp.RespHttp200(c, err, resp) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
for _, v := range respPb.ChatLogs { for _, v := range respPb.ChatLogs {
@ -58,5 +55,5 @@ func GetChatLogs(c *gin.Context) {
resp.CurrentPage = int(respPb.Pagination.CurrentPage) resp.CurrentPage = int(respPb.Pagination.CurrentPage)
resp.ChatLogsNum = int(respPb.ChatLogsNum) resp.ChatLogsNum = int(respPb.ChatLogsNum)
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp", resp) log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp", resp)
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg, "data": resp})
} }

@ -1,11 +1,11 @@
package middleware package middleware
import ( import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/http"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"net/http"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
@ -17,7 +17,7 @@ func JWTAuth() gin.HandlerFunc {
if !ok { if !ok {
log.NewError("", "GetUserIDFromToken false ", c.Request.Header.Get("token")) log.NewError("", "GetUserIDFromToken false ", c.Request.Header.Get("token"))
c.Abort() c.Abort()
http.RespHttp200(c, constant.ErrParseToken, nil) c.JSON(http.StatusOK, gin.H{"errCode": 400, "errMsg": errInfo})
return return
} else { } else {
log.NewInfo("0", utils.GetSelfFuncName(), "failed: ", errInfo) log.NewInfo("0", utils.GetSelfFuncName(), "failed: ", errInfo)

@ -28,25 +28,17 @@ func NewGinRouter() *gin.Engine {
r2.Use(middleware.JWTAuth()) r2.Use(middleware.JWTAuth())
statisticsRouterGroup := r2.Group("/statistics") statisticsRouterGroup := r2.Group("/statistics")
{ {
statisticsRouterGroup.GET("/get_messages_statistics", statistics.GetMessagesStatistics) statisticsRouterGroup.POST("/get_messages_statistics", statistics.GetMessagesStatistics)
statisticsRouterGroup.GET("/get_user_statistics", statistics.GetUserStatistics) statisticsRouterGroup.POST("/get_user_statistics", statistics.GetUserStatistics)
statisticsRouterGroup.GET("/get_group_statistics", statistics.GetGroupStatistics) statisticsRouterGroup.POST("/get_group_statistics", statistics.GetGroupStatistics)
statisticsRouterGroup.GET("/get_active_user", statistics.GetActiveUser) statisticsRouterGroup.POST("/get_active_user", statistics.GetActiveUser)
statisticsRouterGroup.GET("/get_active_group", statistics.GetActiveGroup) statisticsRouterGroup.POST("/get_active_group", statistics.GetActiveGroup)
} }
groupRouterGroup := r2.Group("/group") groupRouterGroup := r2.Group("/group")
{ {
groupRouterGroup.GET("/get_group_by_id", group.GetGroupByID) groupRouterGroup.POST("/get_groups", group.GetGroups)
groupRouterGroup.GET("/get_groups", group.GetGroups) groupRouterGroup.POST("/get_group_members", group.GetGroupMembers)
groupRouterGroup.GET("/get_group_by_name", group.GetGroupByName) groupRouterGroup.POST("/get_members_in_group", group.GetGroupMembers)
groupRouterGroup.GET("/get_group_members", group.GetGroupMembers)
// groupRouterGroup.POST("/create_group", group.CreateGroup)
// groupRouterGroup.POST("/add_members", group.AddGroupMembers)
// groupRouterGroup.POST("/remove_members", group.RemoveGroupMembers)
// groupRouterGroup.POST("/get_members_in_group", group.GetGroupMembers)
// groupRouterGroup.POST("/set_group_master", group.SetGroupOwner)
// groupRouterGroup.POST("/set_group_ordinary_user", group.SetGroupOrdinaryUsers)
// groupRouterGroup.POST("/alter_group_info", group.AlterGroupInfo)
} }
userRouterGroup := r2.Group("/user") userRouterGroup := r2.Group("/user")
{ {

@ -21,7 +21,7 @@ func GetMessagesStatistics(c *gin.Context) {
reqPb admin.GetMessageStatisticsReq reqPb admin.GetMessageStatisticsReq
) )
reqPb.StatisticsReq = &admin.StatisticsReq{} reqPb.StatisticsReq = &admin.StatisticsReq{}
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
@ -75,7 +75,7 @@ func GetUserStatistics(c *gin.Context) {
reqPb admin.GetUserStatisticsReq reqPb admin.GetUserStatisticsReq
) )
reqPb.StatisticsReq = &admin.StatisticsReq{} reqPb.StatisticsReq = &admin.StatisticsReq{}
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
@ -138,7 +138,7 @@ func GetGroupStatistics(c *gin.Context) {
reqPb admin.GetGroupStatisticsReq reqPb admin.GetGroupStatisticsReq
) )
reqPb.StatisticsReq = &admin.StatisticsReq{} reqPb.StatisticsReq = &admin.StatisticsReq{}
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "BindJSON failed ", err.Error()) log.NewError(req.OperationID, "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
@ -195,7 +195,7 @@ func GetActiveUser(c *gin.Context) {
reqPb admin.GetActiveUserReq reqPb admin.GetActiveUserReq
) )
reqPb.StatisticsReq = &admin.StatisticsReq{} reqPb.StatisticsReq = &admin.StatisticsReq{}
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(req.OperationID, "BindJSON failed ", err.Error()) log.NewError(req.OperationID, "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
@ -229,8 +229,8 @@ func GetActiveGroup(c *gin.Context) {
reqPb admin.GetActiveGroupReq reqPb admin.GetActiveGroupReq
) )
reqPb.StatisticsReq = &admin.StatisticsReq{} reqPb.StatisticsReq = &admin.StatisticsReq{}
if err := c.Bind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()}) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }

@ -3,15 +3,12 @@ package user
import ( import (
"Open_IM/pkg/cms_api_struct" "Open_IM/pkg/cms_api_struct"
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
openIMHttp "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/grpc-etcdv3/getcdv3" "Open_IM/pkg/grpc-etcdv3/getcdv3"
commonPb "Open_IM/pkg/proto/sdk_ws" commonPb "Open_IM/pkg/proto/sdk_ws"
pb "Open_IM/pkg/proto/user" pb "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"fmt"
"net/http" "net/http"
"strings" "strings"
@ -25,7 +22,7 @@ func AddUser(c *gin.Context) {
) )
if err := c.BindJSON(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, nil) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -39,23 +36,24 @@ func AddUser(c *gin.Context) {
return return
} }
client := pb.NewUserClient(etcdConn) client := pb.NewUserClient(etcdConn)
_, err := client.AddUser(context.Background(), &reqPb) respPb, err := client.AddUser(context.Background(), &reqPb)
if err != nil { if err != nil {
openIMHttp.RespHttp200(c, err, nil) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), reqPb.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
openIMHttp.RespHttp200(c, constant.OK, nil) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg})
} }
func BlockUser(c *gin.Context) { func BlockUser(c *gin.Context) {
var ( var (
req cms_api_struct.BlockUserRequest req cms_api_struct.BlockUserRequest
resp cms_api_struct.BlockUserResponse // resp cms_api_struct.BlockUserResponse
reqPb pb.BlockUserReq reqPb pb.BlockUserReq
) )
if err := c.BindJSON(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError("0", "BindJSON failed ", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, resp) c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -69,13 +67,13 @@ func BlockUser(c *gin.Context) {
return return
} }
client := pb.NewUserClient(etcdConn) client := pb.NewUserClient(etcdConn)
fmt.Println(reqPb) respPb, err := client.BlockUser(context.Background(), &reqPb)
_, err := client.BlockUser(context.Background(), &reqPb)
if err != nil { if err != nil {
openIMHttp.RespHttp200(c, err, resp) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), reqPb.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg})
} }
func UnblockUser(c *gin.Context) { func UnblockUser(c *gin.Context) {
@ -84,9 +82,9 @@ func UnblockUser(c *gin.Context) {
resp cms_api_struct.UnBlockUserResponse resp cms_api_struct.UnBlockUserResponse
reqPb pb.UnBlockUserReq reqPb pb.UnBlockUserReq
) )
if err := c.ShouldBind(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError("0", "BindJSON failed ", err.Error()) log.NewError(req.OperationID, "BindJSON failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, resp) c.JSON(http.StatusBadRequest, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -100,13 +98,14 @@ func UnblockUser(c *gin.Context) {
return return
} }
client := pb.NewUserClient(etcdConn) client := pb.NewUserClient(etcdConn)
_, err := client.UnBlockUser(context.Background(), &reqPb) respPb, err := client.UnBlockUser(context.Background(), &reqPb)
if err != nil { if err != nil {
openIMHttp.RespHttp200(c, err, resp) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), err.Error(), reqPb.String())
c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp) log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg})
} }
func GetBlockUsers(c *gin.Context) { func GetBlockUsers(c *gin.Context) {
@ -117,9 +116,9 @@ func GetBlockUsers(c *gin.Context) {
respPb *pb.GetBlockUsersResp respPb *pb.GetBlockUsersResp
) )
reqPb.Pagination = &commonPb.RequestPagination{} reqPb.Pagination = &commonPb.RequestPagination{}
if err := c.ShouldBindQuery(&req); err != nil { if err := c.BindJSON(&req); err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
openIMHttp.RespHttp200(c, constant.ErrArgs, resp) c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
return return
} }
reqPb.OperationID = utils.OperationIDGenerator() reqPb.OperationID = utils.OperationIDGenerator()
@ -137,7 +136,7 @@ func GetBlockUsers(c *gin.Context) {
respPb, err := client.GetBlockUsers(context.Background(), &reqPb) respPb, err := client.GetBlockUsers(context.Background(), &reqPb)
if err != nil { if err != nil {
log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetBlockUsers rpc", err.Error()) log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetBlockUsers rpc", err.Error())
openIMHttp.RespHttp200(c, err, resp) c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
return return
} }
for _, v := range respPb.BlockUsers { for _, v := range respPb.BlockUsers {
@ -149,7 +148,6 @@ func GetBlockUsers(c *gin.Context) {
PhoneNumber: v.UserInfo.PhoneNumber, PhoneNumber: v.UserInfo.PhoneNumber,
Email: v.UserInfo.Email, Email: v.UserInfo.Email,
Gender: int(v.UserInfo.Gender), Gender: int(v.UserInfo.Gender),
// CreateTime: v.UserInfo.CreateTime,
}, },
BeginDisableTime: v.BeginDisableTime, BeginDisableTime: v.BeginDisableTime,
EndDisableTime: v.EndDisableTime, EndDisableTime: v.EndDisableTime,
@ -159,5 +157,5 @@ func GetBlockUsers(c *gin.Context) {
resp.CurrentPage = int(respPb.Pagination.CurrentPage) resp.CurrentPage = int(respPb.Pagination.CurrentPage)
resp.UserNums = respPb.UserNums resp.UserNums = respPb.UserNums
log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", resp) log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "req: ", resp)
openIMHttp.RespHttp200(c, constant.OK, resp) c.JSON(http.StatusOK, gin.H{"errCode": respPb.CommonResp.ErrCode, "errMsg": respPb.CommonResp.ErrMsg, "data": resp})
} }

@ -140,7 +140,7 @@ func (s *adminCMSServer) ReduceUserRegisterAddFriendIDList(_ context.Context, re
} }
} }
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
return resp, nil return resp, nil
} }
func (s *adminCMSServer) GetUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.GetUserRegisterAddFriendIDListReq) (*pbAdminCMS.GetUserRegisterAddFriendIDListResp, error) { func (s *adminCMSServer) GetUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.GetUserRegisterAddFriendIDListReq) (*pbAdminCMS.GetUserRegisterAddFriendIDListResp, error) {
@ -223,7 +223,7 @@ func (s *adminCMSServer) GetChatLogs(_ context.Context, req *pbAdminCMS.GetChatL
} }
pbChatLog.SenderNickname = recvUser.Nickname pbChatLog.SenderNickname = recvUser.Nickname
case constant.GroupChatType: case constant.GroupChatType, constant.SuperGroupChatType:
group, err := imdb.GetGroupInfoByGroupID(chatLog.RecvID) group, err := imdb.GetGroupInfoByGroupID(chatLog.RecvID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed") log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed")

@ -6,7 +6,7 @@ import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/db/rocks_cache" rocksCache "Open_IM/pkg/common/db/rocks_cache"
"Open_IM/pkg/common/http" "Open_IM/pkg/common/http"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/common/token_verify" "Open_IM/pkg/common/token_verify"
@ -19,12 +19,13 @@ import (
pbUser "Open_IM/pkg/proto/user" pbUser "Open_IM/pkg/proto/user"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"google.golang.org/grpc"
"math/big" "math/big"
"net" "net"
"strconv" "strconv"
"strings" "strings"
"time" "time"
"google.golang.org/grpc"
) )
type groupServer struct { type groupServer struct {
@ -315,7 +316,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
log.NewError(req.OperationID, "InsertIntoGroupRequest failed ", err.Error(), groupRequest) // log.NewError(req.OperationID, "InsertIntoGroupRequest failed ", err.Error(), groupRequest)
// return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil // return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
} else { } else {
var resultNode pbGroup.Id2Result var resultNode pbGroup.Id2Result
@ -826,7 +827,6 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) { func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.GroupApplicationResponseReq) (*pbGroup.GroupApplicationResponseResp, error) {
log.NewInfo(req.OperationID, "GroupApplicationResponse args ", req.String()) log.NewInfo(req.OperationID, "GroupApplicationResponse args ", req.String())
groupRequest := db.GroupRequest{} groupRequest := db.GroupRequest{}
utils.CopyStructFields(&groupRequest, req) utils.CopyStructFields(&groupRequest, req)
groupRequest.UserID = req.FromUserID groupRequest.UserID = req.FromUserID
@ -1335,139 +1335,53 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
} }
func (s *groupServer) GetGroupByID(_ context.Context, req *pbGroup.GetGroupByIDReq) (*pbGroup.GetGroupByIDResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbGroup.GetGroupByIDResp{CMSGroup: &pbGroup.CMSGroup{
GroupInfo: &open_im_sdk.GroupInfo{},
}}
group, err := imdb.GetGroupInfoByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById error", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
utils.CopyStructFields(resp.CMSGroup.GroupInfo, group)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(group.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
groupMemberNum, err := imdb.GetGroupMemberNumByGroupID(req.GroupID)
if err == nil {
resp.CMSGroup.GroupInfo.MemberCount = uint32(groupMemberNum)
} else {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
}
resp.CMSGroup.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroup.GroupOwnerUserID = groupMember.UserID
resp.CMSGroup.GroupInfo.CreatorUserID = group.CreatorUserID
resp.CMSGroup.GroupInfo.CreateTime = uint32(group.CreateTime.Unix())
utils.CopyStructFields(resp.CMSGroup.GroupInfo, group)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil
}
func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pbGroup.GetGroupResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbGroup.GetGroupResp{
CMSGroups: []*pbGroup.CMSGroup{},
}
groups, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsByName error", req.String(), req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
return resp, http.WrapError(constant.ErrDB)
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "groups", groups)
nums, err := imdb.GetGroupsCountNum(db.Group{GroupName: req.GroupName})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum error", err.Error(), req.GroupName)
return resp, http.WrapError(constant.ErrDB)
}
resp.GroupNums = nums
resp.Pagination = &open_im_sdk.RequestPagination{
PageNumber: req.Pagination.PageNumber,
ShowNumber: req.Pagination.ShowNumber,
}
for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster error", err.Error())
continue
}
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
group.GroupOwnerUserID = groupMember.UserID
group.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroups = append(resp.CMSGroups, group)
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
return resp, nil
}
func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) { func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", req.String())
resp := &pbGroup.GetGroupsResp{ resp := &pbGroup.GetGroupsResp{
CMSGroups: []*pbGroup.CMSGroup{}, CMSGroups: []*pbGroup.CMSGroup{},
Pagination: &open_im_sdk.RequestPagination{}, Pagination: &open_im_sdk.ResponsePagination{},
}
groups, err := imdb.GetGroups(int(req.Pagination.PageNumber), int(req.Pagination.ShowNumber))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroups error", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
resp.GroupNum, err = imdb.GetGroupsCountNum(db.Group{})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum error", err.Error())
return resp, http.WrapError(constant.ErrDB)
} }
resp.Pagination.PageNumber = req.Pagination.PageNumber if req.GroupID != "" {
resp.Pagination.ShowNumber = req.Pagination.ShowNumber groupInfoDB, err := imdb.GetGroupInfoByGroupID(req.GroupID)
for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster failed", err.Error(), v) log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
continue resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix()) resp.GroupNum = 1
group.GroupOwnerUserID = groupMember.UserID groupInfo := &open_im_sdk.GroupInfo{}
group.GroupOwnerUserName = groupMember.Nickname utils.CopyStructFields(groupInfo, groupInfoDB)
resp.CMSGroups = append(resp.CMSGroups, group) resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{GroupInfo: groupInfo})
} } else {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", resp.String()) groups, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
return resp, nil
}
func (s *groupServer) OperateUserRole(_ context.Context, req *pbGroup.OperateUserRoleReq) (*pbGroup.OperateUserRoleResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
resp := &pbGroup.OperateUserRoleResp{}
oldOwnerUserID, err := imdb.GetGroupOwnerInfoByGroupID(req.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster failed", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
etcdConn := getcdv3.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)
return resp, http.WrapError(constant.ErrInternal)
}
client := pbGroup.NewGroupClient(etcdConn)
var reqPb pbGroup.TransferGroupOwnerReq
reqPb.OperationID = req.OperationID
reqPb.NewOwnerUserID = req.UserID
reqPb.GroupID = req.GroupID
reqPb.OpUserID = "cms admin"
reqPb.OldOwnerUserID = oldOwnerUserID.UserID
reply, err := client.TransferGroupOwner(context.Background(), &reqPb)
if reply.CommonResp.ErrCode != 0 || err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "TransferGroupOwner rpc failed")
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsByName error", req.String(), req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
}
for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupOwnerInfoByGroupID failed", err.Error(), v)
continue
}
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
group.GroupOwnerUserID = groupMember.UserID
group.GroupOwnerUserName = groupMember.Nickname
resp.CMSGroups = append(resp.CMSGroups, group)
}
resp.GroupNum, err = imdb.GetGroupsCountNum(db.Group{GroupName: req.GroupName})
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum error", err.Error())
resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
} }
resp.Pagination.CurrentPage = req.Pagination.PageNumber
resp.Pagination.ShowNumber = req.Pagination.ShowNumber
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups resp", resp.String())
return resp, nil return resp, nil
} }
@ -1477,12 +1391,16 @@ func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGrou
groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupID, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersByGroupIdCMS Error", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersByGroupIdCMS Error", err.Error())
return resp, http.WrapError(constant.ErrDB) resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupID, req.UserName) groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupID, req.UserName)
if err != nil { if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS Error", err.Error()) log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS Error", err.Error())
return resp, http.WrapError(constant.ErrDB) resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
resp.CommonResp.ErrMsg = err.Error()
return resp, nil
} }
log.NewInfo(req.OperationID, groupMembersCount) log.NewInfo(req.OperationID, groupMembersCount)
resp.MemberNums = int32(groupMembersCount) resp.MemberNums = int32(groupMembersCount)
@ -1501,151 +1419,6 @@ func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGrou
return resp, nil return resp, nil
} }
func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.RemoveGroupMembersCMSReq) (*pbGroup.RemoveGroupMembersCMSResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
resp := &pbGroup.RemoveGroupMembersCMSResp{}
for _, userId := range req.UserIDList {
err := imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, userId)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
resp.Failed = append(resp.Failed, userId)
} else {
resp.Success = append(resp.Success, userId)
}
}
reqKick := &pbGroup.KickGroupMemberReq{
GroupID: req.GroupID,
KickedUserIDList: resp.Success,
Reason: "admin kick",
OperationID: req.OperationID,
OpUserID: req.OpUserID,
}
var reqPb pbUser.SetConversationReq
var c pbConversation.Conversation
for _, v := range resp.Success {
reqPb.OperationID = req.OperationID
c.OwnerUserID = v
c.ConversationID = utils.GetConversationIDBySessionType(req.GroupID, constant.GroupChatType)
c.ConversationType = constant.GroupChatType
c.GroupID = req.GroupID
c.IsNotInGroup = true
reqPb.Conversation = &c
etcdConn := getcdv3.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)
return resp, http.WrapError(constant.ErrInternal)
}
client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "SetConversation rpc failed, ", reqPb.String(), err.Error(), v)
} else {
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "SetConversation success", respPb.String(), v)
}
}
etcdConn := getcdv3.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)
return resp, http.WrapError(constant.ErrDB)
}
cacheClient := pbCache.NewCacheClient(etcdConn)
cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
GroupID: req.GroupID,
OperationID: req.OperationID,
})
if err != nil {
log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
if cacheResp.CommonResp.ErrCode != 0 {
log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
return resp, http.WrapError(constant.ErrDB)
}
if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
}
if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
}
for _, userID := range resp.Success {
if err := rocksCache.DelGroupMemberInfoFromCache(req.GroupID, userID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID, userID)
}
}
chat.MemberKickedNotification(reqKick, resp.Success)
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
return resp, nil
}
func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGroupMembersCMSReq) (*pbGroup.AddGroupMembersCMSResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
resp := &pbGroup.AddGroupMembersCMSResp{}
for _, userId := range req.UserIDList {
if isExist := imdb.IsExistGroupMember(req.GroupID, userId); isExist {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "user is exist in group", userId, req.GroupID)
resp.Failed = append(resp.Failed, userId)
continue
}
user, err := imdb.GetUserByUserID(userId)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID", err.Error())
resp.Failed = append(resp.Failed, userId)
continue
}
groupMember := db.GroupMember{
GroupID: req.GroupID,
UserID: userId,
Nickname: user.Nickname,
FaceURL: "",
RoleLevel: 1,
JoinTime: time.Time{},
JoinSource: constant.JoinByAdmin,
OperatorUserID: "CmsAdmin",
Ex: "",
}
if err := imdb.InsertIntoGroupMember(groupMember); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "InsertIntoGroupMember failed", req.String())
resp.Failed = append(resp.Failed, userId)
} else {
resp.Success = append(resp.Success, userId)
}
}
etcdConn := getcdv3.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)
return resp, http.WrapError(constant.ErrDB)
}
cacheClient := pbCache.NewCacheClient(etcdConn)
cacheResp, err := cacheClient.DelGroupMemberIDListFromCache(context.Background(), &pbCache.DelGroupMemberIDListFromCacheReq{
GroupID: req.GroupID,
OperationID: req.OperationID,
})
if err != nil {
log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc call failed ", err.Error())
return resp, http.WrapError(constant.ErrDB)
}
if cacheResp.CommonResp.ErrCode != 0 {
log.NewError(req.OperationID, "DelGroupMemberIDListFromCache rpc logic call failed ", cacheResp.String())
return resp, http.WrapError(constant.ErrDB)
}
if err := rocksCache.DelGroupMemberListHashFromCache(req.GroupID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
}
if err := rocksCache.DelGroupMemberNumFromCache(req.GroupID); err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
}
chat.MemberInvitedNotification(req.OperationID, req.GroupID, req.OpUserID, "admin add you to group", resp.Success)
return resp, nil
}
func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) { func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbGroup.GetUserReqApplicationListResp{} resp := &pbGroup.GetUserReqApplicationListResp{}

@ -1,182 +0,0 @@
package messageCMS
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db"
errors "Open_IM/pkg/common/http"
"context"
"strconv"
"Open_IM/pkg/common/log"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbMessageCMS "Open_IM/pkg/proto/message_cms"
open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
"net"
"strings"
"google.golang.org/grpc"
)
type messageCMSServer struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
}
func NewMessageCMSServer(port int) *messageCMSServer {
log.NewPrivateLog(constant.LogFileName)
return &messageCMSServer{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImMessageCMSName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
}
func (s *messageCMSServer) Run() {
log.NewInfo("0", "messageCMS rpc start ")
listenIP := ""
if config.Config.ListenIP == "" {
listenIP = "0.0.0.0"
} else {
listenIP = config.Config.ListenIP
}
address := listenIP + ":" + strconv.Itoa(s.rpcPort)
//listener network
listener, err := net.Listen("tcp", address)
if err != nil {
panic("listening err:" + err.Error() + s.rpcRegisterName)
}
log.NewInfo("0", "listen network success, ", address, listener)
defer listener.Close()
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//Service registers with etcd
pbMessageCMS.RegisterMessageCMSServer(srv, s)
rpcRegisterIP := config.Config.RpcRegisterIP
if config.Config.RpcRegisterIP == "" {
rpcRegisterIP, err = utils.GetLocalIP()
if err != nil {
log.Error("", "GetLocalIP failed ", err.Error())
}
}
log.NewInfo("", "rpcRegisterIP", rpcRegisterIP)
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10)
if err != nil {
log.NewError("0", "RegisterEtcd failed ", err.Error())
panic(utils.Wrap(err, "register message_cms module rpc to etcd err"))
}
err = srv.Serve(listener)
if err != nil {
log.NewError("0", "Serve failed ", err.Error())
return
}
log.NewInfo("0", "message cms rpc success")
}
func (s *messageCMSServer) BoradcastMessage(_ context.Context, req *pbMessageCMS.BoradcastMessageReq) (*pbMessageCMS.BoradcastMessageResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "BoradcastMessage", req.String())
resp := &pbMessageCMS.BoradcastMessageResp{}
return resp, errors.WrapError(constant.ErrDB)
}
func (s *messageCMSServer) GetChatLogs(_ context.Context, req *pbMessageCMS.GetChatLogsReq) (*pbMessageCMS.GetChatLogsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String())
resp := &pbMessageCMS.GetChatLogsResp{}
time, err := utils.TimeStringToTime(req.Date)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "time string parse error", err.Error())
}
chatLog := db.ChatLog{
Content: req.Content,
SendTime: time,
ContentType: req.ContentType,
SessionType: req.SessionType,
}
switch chatLog.SessionType {
case constant.SingleChatType:
chatLog.SendID = req.UserId
case constant.GroupChatType:
chatLog.RecvID = req.GroupId
chatLog.SendID = req.UserId
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "chat_log: ", chatLog)
nums, err := imdb.GetChatLogCount(chatLog)
resp.ChatLogsNum = int32(nums)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetChatLogCount", err.Error())
}
chatLogs, err := imdb.GetChatLog(chatLog, req.Pagination.PageNumber, req.Pagination.ShowNumber)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetChatLog", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
for _, chatLog := range chatLogs {
pbChatLog := &pbMessageCMS.ChatLogs{
SessionType: chatLog.SessionType,
ContentType: chatLog.ContentType,
SearchContent: req.Content,
WholeContent: chatLog.Content,
Date: chatLog.CreateTime.String(),
SenderNickName: chatLog.SenderNickname,
SenderId: chatLog.SendID,
}
if chatLog.SenderNickname == "" {
sendUser, err := imdb.GetUserByUserID(chatLog.SendID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error())
continue
}
pbChatLog.SenderNickName = sendUser.Nickname
}
switch chatLog.SessionType {
case constant.SingleChatType:
recvUser, err := imdb.GetUserByUserID(chatLog.RecvID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error())
continue
}
pbChatLog.ReciverId = recvUser.UserID
pbChatLog.ReciverNickName = recvUser.Nickname
case constant.GroupChatType:
group, err := imdb.GetGroupInfoByGroupID(chatLog.RecvID)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed")
continue
}
pbChatLog.GroupId = group.GroupID
pbChatLog.GroupName = group.GroupName
}
resp.ChatLogs = append(resp.ChatLogs, pbChatLog)
}
resp.Pagination = &open_im_sdk.ResponsePagination{
CurrentPage: req.Pagination.PageNumber,
ShowNumber: req.Pagination.ShowNumber,
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp output: ", resp.String())
return resp, nil
}
func (s *messageCMSServer) MassSendMessage(_ context.Context, req *pbMessageCMS.MassSendMessageReq) (*pbMessageCMS.MassSendMessageResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "MassSendMessage", req.String())
resp := &pbMessageCMS.MassSendMessageResp{}
return resp, nil
}
func (s *messageCMSServer) WithdrawMessage(_ context.Context, req *pbMessageCMS.WithdrawMessageReq) (*pbMessageCMS.WithdrawMessageResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "WithdrawMessage", req.String())
resp := &pbMessageCMS.WithdrawMessageResp{}
return resp, nil
}

@ -1,399 +0,0 @@
package statistics
import (
"Open_IM/pkg/common/config"
"Open_IM/pkg/common/constant"
"context"
"strconv"
"sync"
"time"
//"Open_IM/pkg/common/constant"
//"Open_IM/pkg/common/db"
imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
"Open_IM/pkg/common/log"
//cp "Open_IM/pkg/common/utils"
"Open_IM/pkg/grpc-etcdv3/getcdv3"
pbStatistics "Open_IM/pkg/proto/statistics"
//open_im_sdk "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils"
//"context"
errors "Open_IM/pkg/common/http"
"net"
"strings"
"google.golang.org/grpc"
)
type statisticsServer struct {
rpcPort int
rpcRegisterName string
etcdSchema string
etcdAddr []string
}
func NewStatisticsServer(port int) *statisticsServer {
log.NewPrivateLog(constant.LogFileName)
return &statisticsServer{
rpcPort: port,
rpcRegisterName: config.Config.RpcRegisterName.OpenImStatisticsName,
etcdSchema: config.Config.Etcd.EtcdSchema,
etcdAddr: config.Config.Etcd.EtcdAddr,
}
}
func (s *statisticsServer) Run() {
log.NewInfo("0", "Statistics rpc start ")
listenIP := ""
if config.Config.ListenIP == "" {
listenIP = "0.0.0.0"
} else {
listenIP = config.Config.ListenIP
}
address := listenIP + ":" + strconv.Itoa(s.rpcPort)
//listener network
listener, err := net.Listen("tcp", address)
if err != nil {
panic("listening err:" + err.Error() + s.rpcRegisterName)
}
log.NewInfo("0", "listen network success, ", address, listener)
defer listener.Close()
//grpc server
srv := grpc.NewServer()
defer srv.GracefulStop()
//Service registers with etcd
pbStatistics.RegisterUserServer(srv, s)
rpcRegisterIP := config.Config.RpcRegisterIP
if config.Config.RpcRegisterIP == "" {
rpcRegisterIP, err = utils.GetLocalIP()
if err != nil {
log.Error("", "GetLocalIP failed ", err.Error())
}
}
err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10)
if err != nil {
log.NewError("0", "RegisterEtcd failed ", err.Error())
panic(utils.Wrap(err, "register statistics module rpc to etcd err"))
}
err = srv.Serve(listener)
if err != nil {
log.NewError("0", "Serve failed ", err.Error())
return
}
log.NewInfo("0", "statistics rpc success")
}
func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.GetActiveGroupReq) (*pbStatistics.GetActiveGroupResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req", req.String())
resp := &pbStatistics.GetActiveGroupResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
return resp, errors.WrapError(constant.ErrArgs)
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "time: ", fromTime, toTime)
activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveGroups failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
for _, activeGroup := range activeGroups {
resp.Groups = append(resp.Groups,
&pbStatistics.GroupResp{
GroupName: activeGroup.Name,
GroupId: activeGroup.Id,
MessageNum: int32(activeGroup.MessageNum),
})
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
return resp, nil
}
func (s *statisticsServer) GetActiveUser(_ context.Context, req *pbStatistics.GetActiveUserReq) (*pbStatistics.GetActiveUserResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
resp := &pbStatistics.GetActiveUserResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "time: ", fromTime, toTime)
activeUsers, err := imdb.GetActiveUsers(fromTime, toTime, 12)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUsers failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
for _, activeUser := range activeUsers {
resp.Users = append(resp.Users,
&pbStatistics.UserResp{
UserId: activeUser.Id,
NickName: activeUser.Name,
MessageNum: int32(activeUser.MessageNum),
},
)
}
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), resp.String())
return resp, nil
}
func ParseTimeFromTo(from, to string) (time.Time, time.Time, error) {
var fromTime time.Time
var toTime time.Time
fromTime, err := utils.TimeStringToTime(from)
if err != nil {
return fromTime, toTime, err
}
toTime, err = utils.TimeStringToTime(to)
if err != nil {
return fromTime, toTime, err
}
return fromTime, toTime, nil
}
func isInOneMonth(from, to time.Time) bool {
return from.Month() == to.Month() && from.Year() == to.Year()
}
func GetRangeDate(from, to time.Time) [][2]time.Time {
interval := to.Sub(from)
var times [][2]time.Time
switch {
// today
case interval == 0:
times = append(times, [2]time.Time{
from, from.Add(time.Hour * 24),
})
// days
case isInOneMonth(from, to):
for i := 0; ; i++ {
fromTime := from.Add(time.Hour * 24 * time.Duration(i))
toTime := from.Add(time.Hour * 24 * time.Duration(i+1))
if toTime.After(to.Add(time.Hour * 24)) {
break
}
times = append(times, [2]time.Time{
fromTime, toTime,
})
}
// month
case !isInOneMonth(from, to):
if to.Sub(from) < time.Hour*24*30 {
for i := 0; ; i++ {
fromTime := from.Add(time.Hour * 24 * time.Duration(i))
toTime := from.Add(time.Hour * 24 * time.Duration(i+1))
if toTime.After(to.Add(time.Hour * 24)) {
break
}
times = append(times, [2]time.Time{
fromTime, toTime,
})
}
} else {
for i := 0; ; i++ {
if i == 0 {
fromTime := from
toTime := getFirstDateOfNextNMonth(fromTime, 1)
times = append(times, [2]time.Time{
fromTime, toTime,
})
} else {
fromTime := getFirstDateOfNextNMonth(from, i)
toTime := getFirstDateOfNextNMonth(fromTime, 1)
if toTime.After(to) {
toTime = to
times = append(times, [2]time.Time{
fromTime, toTime,
})
break
}
times = append(times, [2]time.Time{
fromTime, toTime,
})
}
}
}
}
return times
}
func getFirstDateOfNextNMonth(currentTime time.Time, n int) time.Time {
lastOfMonth := time.Date(currentTime.Year(), currentTime.Month(), 1, 0, 0, 0, 0, currentTime.Location()).AddDate(0, n, 0)
return lastOfMonth
}
func (s *statisticsServer) GetGroupStatistics(_ context.Context, req *pbStatistics.GetGroupStatisticsReq) (*pbStatistics.GetGroupStatisticsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
resp := &pbStatistics.GetGroupStatisticsResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupStatistics failed", err.Error())
return resp, errors.WrapError(constant.ErrArgs)
}
increaseGroupNum, err := imdb.GetIncreaseGroupNum(fromTime, toTime.Add(time.Hour*24))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum failed", err.Error(), fromTime, toTime)
return resp, errors.WrapError(constant.ErrDB)
}
totalGroupNum, err := imdb.GetTotalGroupNum()
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
resp.IncreaseGroupNum = increaseGroupNum
resp.TotalGroupNum = totalGroupNum
times := GetRangeDate(fromTime, toTime)
log.NewDebug(req.OperationID, "times:", times)
wg := &sync.WaitGroup{}
resp.IncreaseGroupNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
resp.TotalGroupNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
wg.Add(len(times))
for i, v := range times {
go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
defer wg.Done()
num, err := imdb.GetIncreaseGroupNum(v[0], v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
}
resp.IncreaseGroupNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
num, err = imdb.GetGroupNum(v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
}
resp.TotalGroupNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
}(wg, i, v)
}
wg.Wait()
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
return resp, nil
}
func (s *statisticsServer) GetMessageStatistics(_ context.Context, req *pbStatistics.GetMessageStatisticsReq) (*pbStatistics.GetMessageStatisticsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
resp := &pbStatistics.GetMessageStatisticsResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), "times: ", fromTime, toTime)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
return resp, errors.WrapError(constant.ErrArgs)
}
privateMessageNum, err := imdb.GetPrivateMessageNum(fromTime, toTime.Add(time.Hour*24))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetPrivateMessageNum failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
groupMessageNum, err := imdb.GetGroupMessageNum(fromTime, toTime.Add(time.Hour*24))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMessageNum failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
log.NewDebug(req.OperationID, utils.GetSelfFuncName(), privateMessageNum, groupMessageNum)
resp.PrivateMessageNum = privateMessageNum
resp.GroupMessageNum = groupMessageNum
times := GetRangeDate(fromTime, toTime)
resp.GroupMessageNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
resp.PrivateMessageNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
wg := &sync.WaitGroup{}
wg.Add(len(times))
for i, v := range times {
go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
defer wg.Done()
num, err := imdb.GetPrivateMessageNum(v[0], v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
}
resp.PrivateMessageNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
num, err = imdb.GetGroupMessageNum(v[0], v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
}
resp.GroupMessageNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
}(wg, i, v)
}
wg.Wait()
return resp, nil
}
func (s *statisticsServer) GetUserStatistics(_ context.Context, req *pbStatistics.GetUserStatisticsReq) (*pbStatistics.GetUserStatisticsResp, error) {
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
resp := &pbStatistics.GetUserStatisticsResp{}
fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo failed", err.Error())
return resp, errors.WrapError(constant.ErrArgs)
}
activeUserNum, err := imdb.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUserNum failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
increaseUserNum, err := imdb.GetIncreaseUserNum(fromTime, toTime.Add(time.Hour*24))
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
totalUserNum, err := imdb.GetTotalUserNum()
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNum failed", err.Error())
return resp, errors.WrapError(constant.ErrDB)
}
resp.ActiveUserNum = activeUserNum
resp.TotalUserNum = totalUserNum
resp.IncreaseUserNum = increaseUserNum
times := GetRangeDate(fromTime, toTime)
resp.TotalUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
resp.ActiveUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
resp.IncreaseUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times))
wg := &sync.WaitGroup{}
wg.Add(len(times))
for i, v := range times {
go func(wg *sync.WaitGroup, index int, v [2]time.Time) {
defer wg.Done()
num, err := imdb.GetActiveUserNum(v[0], v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
}
resp.ActiveUserNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
num, err = imdb.GetTotalUserNumByDate(v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNumByDate", v, err.Error())
}
resp.TotalUserNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
num, err = imdb.GetIncreaseUserNum(v[0], v[1])
if err != nil {
log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum", v, err.Error())
}
resp.IncreaseUserNumList[index] = &pbStatistics.DateNumList{
Date: v[0].String(),
Num: num,
}
}(wg, i, v)
}
wg.Wait()
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp)
return resp, nil
}

@ -6,7 +6,7 @@ import (
) )
type AdminLoginRequest struct { type AdminLoginRequest struct {
AdminName string `json:"adminName" binding:"required"` AdminName string `json:"adminID" binding:"required"`
Secret string `json:"secret" binding:"required"` Secret string `json:"secret" binding:"required"`
OperationID string `json:"operationID" binding:"required"` OperationID string `json:"operationID" binding:"required"`
} }

@ -1,9 +1,8 @@
package cms_api_struct package cms_api_struct
type GroupResponse struct { type GroupResponse struct {
GroupOwnerName string `json:"GroupOwnerName"` GroupOwnerName string `json:"GroupOwnerName"`
GroupOwnerID string `json:"GroupOwnerID"` GroupOwnerID string `json:"GroupOwnerID"`
//*server_api_params.GroupInfo
GroupID string `json:"groupID"` GroupID string `json:"groupID"`
GroupName string `json:"groupName"` GroupName string `json:"groupName"`
Notification string `json:"notification"` Notification string `json:"notification"`
@ -23,27 +22,9 @@ type GroupResponse struct {
NotificationUserID string `json:"notificationUserID"` NotificationUserID string `json:"notificationUserID"`
} }
type GetGroupByIDRequest struct {
GroupID string `form:"groupID" binding:"required"`
}
type GetGroupByIDResponse struct {
GroupResponse
}
type GetGroupRequest struct {
GroupName string `form:"groupName" binding:"required"`
RequestPagination
}
type GetGroupResponse struct {
Groups []GroupResponse `json:"groups"`
GroupNums int `json:"groupNums"`
ResponsePagination
}
type GetGroupsRequest struct { type GetGroupsRequest struct {
RequestPagination RequestPagination
OperationID string `json:"operationID"`
} }
type GetGroupsResponse struct { type GetGroupsResponse struct {
@ -52,55 +33,10 @@ type GetGroupsResponse struct {
ResponsePagination ResponsePagination
} }
type CreateGroupRequest struct {
GroupName string `json:"groupName" binding:"required"`
GroupMasterId string `json:"groupOwnerID" binding:"required"`
GroupMembers []string `json:"groupMembers" binding:"required"`
}
type CreateGroupResponse struct {
}
type SetGroupMasterRequest struct {
GroupId string `json:"groupID" binding:"required"`
UserId string `json:"userID" binding:"required"`
}
type SetGroupMasterResponse struct {
}
type SetGroupMemberRequest struct {
GroupId string `json:"groupID" binding:"required"`
UserId string `json:"userID" binding:"required"`
}
type SetGroupMemberRespones struct {
}
type BanGroupChatRequest struct {
GroupId string `json:"groupID" binding:"required"`
}
type BanGroupChatResponse struct {
}
type BanPrivateChatRequest struct {
GroupId string `json:"groupID" binding:"required"`
}
type BanPrivateChatResponse struct {
}
type DeleteGroupRequest struct {
GroupId string `json:"groupID" binding:"required"`
}
type DeleteGroupResponse struct {
}
type GetGroupMembersRequest struct { type GetGroupMembersRequest struct {
GroupID string `form:"groupID" binding:"required"` GroupID string `form:"groupID" binding:"required"`
UserName string `form:"userName"` UserName string `form:"userName"`
OperationID string `json:"operationID"`
RequestPagination RequestPagination
} }
@ -124,41 +60,3 @@ type GetGroupMembersResponse struct {
ResponsePagination ResponsePagination
MemberNums int `json:"memberNums"` MemberNums int `json:"memberNums"`
} }
type GroupMemberRequest struct {
GroupId string `json:"groupID" binding:"required"`
Members []string `json:"members" binding:"required"`
}
type GroupMemberOperateResponse struct {
Success []string `json:"success"`
Failed []string `json:"failed"`
}
type AddGroupMembersRequest struct {
GroupMemberRequest
}
type AddGroupMembersResponse struct {
GroupMemberOperateResponse
}
type RemoveGroupMembersRequest struct {
GroupMemberRequest
}
type RemoveGroupMembersResponse struct {
GroupMemberOperateResponse
}
type AlterGroupInfoRequest struct {
GroupID string `json:"groupID"`
GroupName string `json:"groupName"`
Notification string `json:"notification"`
Introduction string `json:"introduction"`
ProfilePhoto string `json:"profilePhoto"`
GroupType int `json:"groupType"`
}
type AlterGroupInfoResponse struct {
}

@ -17,63 +17,15 @@ type UserResponse struct {
Gender int `json:"gender"` Gender int `json:"gender"`
} }
type GetUserRequest struct {
UserId string `form:"user_id" binding:"required"`
}
type GetUserResponse struct {
UserResponse
}
type GetUsersRequest struct {
RequestPagination
}
type GetUsersResponse struct {
Users []*UserResponse `json:"users"`
ResponsePagination
UserNums int32 `json:"user_nums"`
}
type GetUsersByNameRequest struct {
UserName string `form:"user_name" binding:"required"`
RequestPagination
}
type GetUsersByNameResponse struct {
Users []*UserResponse `json:"users"`
ResponsePagination
UserNums int32 `json:"user_nums"`
}
type ResignUserRequest struct {
UserId string `json:"user_id"`
}
type ResignUserResponse struct {
}
type AlterUserRequest struct {
UserId string `json:"user_id" binding:"required"`
Nickname string `json:"nickname"`
PhoneNumber string `json:"phone_number" validate:"len=11"`
Email string `json:"email"`
Birth string `json:"birth"`
Gender string `json:"gender"`
Photo string `json:"photo"`
}
type AlterUserResponse struct {
}
type AddUserRequest struct { type AddUserRequest struct {
PhoneNumber string `json:"phone_number" binding:"required"` OperationID string `json:"operationID"`
UserId string `json:"user_id" binding:"required"` PhoneNumber string `json:"phoneNumber" binding:"required"`
UserId string `json:"userID" binding:"required"`
Name string `json:"name" binding:"required"` Name string `json:"name" binding:"required"`
Email string `json:"email"` Email string `json:"email"`
Birth string `json:"birth"` Birth string `json:"birth"`
Gender string `json:"gender"` Gender string `json:"gender"`
Photo string `json:"photo"` FaceURL string `json:"faceURL"`
} }
type AddUserResponse struct { type AddUserResponse struct {
@ -81,46 +33,34 @@ type AddUserResponse struct {
type BlockUser struct { type BlockUser struct {
UserResponse UserResponse
BeginDisableTime string `json:"begin_disable_time"` BeginDisableTime string `json:"beginDisableTime"`
EndDisableTime string `json:"end_disable_time"` EndDisableTime string `json:"endDisableTime"`
} }
type BlockUserRequest struct { type BlockUserRequest struct {
UserId string `json:"user_id" binding:"required"` OperationID string `json:"operationID"`
EndDisableTime string `json:"end_disable_time" binding:"required"` UserID string `json:"userID" binding:"required"`
EndDisableTime string `json:"endDisableTime" binding:"required"`
} }
type BlockUserResponse struct { type BlockUserResponse struct {
} }
type UnblockUserRequest struct { type UnblockUserRequest struct {
UserId string `json:"user_id" binding:"required"` OperationID string `json:"operationID"`
UserID string `json:"userID" binding:"required"`
} }
type UnBlockUserResponse struct { type UnBlockUserResponse struct {
} }
type GetBlockUsersRequest struct { type GetBlockUsersRequest struct {
OperationID string `json:"operationID"`
RequestPagination RequestPagination
} }
type GetBlockUsersResponse struct { type GetBlockUsersResponse struct {
BlockUsers []BlockUser `json:"block_users"` BlockUsers []BlockUser `json:"blockUsers"`
ResponsePagination ResponsePagination
UserNums int32 `json:"user_nums"` UserNums int32 `json:"userNums"`
}
type GetBlockUserRequest struct {
UserId string `form:"user_id" binding:"required"`
}
type GetBlockUserResponse struct {
BlockUser
}
type DeleteUserRequest struct {
UserId string `json:"user_id" binding:"required"`
}
type DeleteUserResponse struct {
} }

@ -227,17 +227,17 @@ type Black struct {
type ChatLog struct { type ChatLog struct {
ServerMsgID string `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"` ServerMsgID string `gorm:"column:server_msg_id;primary_key;type:char(64)" json:"serverMsgID"`
ClientMsgID string `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"` ClientMsgID string `gorm:"column:client_msg_id;type:char(64)" json:"clientMsgID"`
SendID string `gorm:"column:send_id;type:char(64)" json:"sendID"` SendID string `gorm:"column:send_id;type:char(64);index:search" json:"sendID"`
RecvID string `gorm:"column:recv_id;type:char(64)" json:"recvID"` RecvID string `gorm:"column:recv_id;type:char(64);index:search" json:"recvID"`
SenderPlatformID int32 `gorm:"column:sender_platform_id" json:"senderPlatformID"` SenderPlatformID int32 `gorm:"column:sender_platform_id" json:"senderPlatformID"`
SenderNickname string `gorm:"column:sender_nick_name;type:varchar(255)" json:"senderNickname"` SenderNickname string `gorm:"column:sender_nick_name;type:varchar(255)" json:"senderNickname"`
SenderFaceURL string `gorm:"column:sender_face_url;type:varchar(255)" json:"senderFaceURL"` SenderFaceURL string `gorm:"column:sender_face_url;type:varchar(255)" json:"senderFaceURL"`
SessionType int32 `gorm:"column:session_type" json:"sessionType"` SessionType int32 `gorm:"column:session_type;;index:search" json:"sessionType"`
MsgFrom int32 `gorm:"column:msg_from" json:"msgFrom"` MsgFrom int32 `gorm:"column:msg_from" json:"msgFrom"`
ContentType int32 `gorm:"column:content_type" json:"contentType"` ContentType int32 `gorm:"column:content_type;index:search" json:"contentType"`
Content string `gorm:"column:content;type:varchar(3000)" json:"content"` Content string `gorm:"column:content;type:varchar(3000);index:search" json:"content"`
Status int32 `gorm:"column:status" json:"status"` Status int32 `gorm:"column:status" json:"status"`
SendTime time.Time `gorm:"column:send_time" json:"sendTime"` SendTime time.Time `gorm:"column:send_time;;index:search" json:"sendTime"`
CreateTime time.Time `gorm:"column:create_time" json:"createTime"` CreateTime time.Time `gorm:"column:create_time" json:"createTime"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"` Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
} }

@ -1,6 +1,7 @@
package im_mysql_model package im_mysql_model
import ( import (
"Open_IM/pkg/common/constant"
"Open_IM/pkg/common/db" "Open_IM/pkg/common/db"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
@ -15,8 +16,10 @@ func GetChatLog(chatLog db.ChatLog, pageNumber, showNumber int32) ([]db.ChatLog,
if chatLog.SessionType != 0 { if chatLog.SessionType != 0 {
db = db.Where("session_type = ?", chatLog.SessionType) db = db.Where("session_type = ?", chatLog.SessionType)
} }
if chatLog.ContentType != 0 { if chatLog.ContentType == 1 {
db = db.Where("content_type = ?", chatLog.ContentType) db = db.Where("content_type = ?", chatLog.ContentType)
} else if chatLog.ContentType == 2 {
db = db.Where("content_type in (?)", []int{constant.GroupChatType, constant.SuperGroupChatType})
} }
if chatLog.SendID != "" { if chatLog.SendID != "" {
db = db.Where("send_id = ?", chatLog.SendID) db = db.Where("send_id = ?", chatLog.SendID)

@ -1,43 +0,0 @@
package http
import (
"Open_IM/pkg/common/constant"
"fmt"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
//"Open_IM/pkg/cms_api_struct"
"net/http"
"github.com/gin-gonic/gin"
)
type BaseResp struct {
Code int32 `json:"code"`
ErrMsg string `json:"err_msg"`
Data interface{} `json:"data"`
}
func RespHttp200(ctx *gin.Context, err error, data interface{}) {
var resp BaseResp
switch e := err.(type) {
case constant.ErrInfo:
resp.Code = e.ErrCode
resp.ErrMsg = e.ErrMsg
default:
s, ok := status.FromError(err)
if !ok {
fmt.Println("need grpc format error")
return
}
resp.Code = int32(s.Code())
resp.ErrMsg = s.Message()
}
resp.Data = data
ctx.JSON(http.StatusOK, resp)
}
// warp error
func WrapError(err constant.ErrInfo) error {
return status.Error(codes.Code(err.ErrCode), err.ErrMsg)
}

@ -36,7 +36,7 @@ func (m *CommonResp) Reset() { *m = CommonResp{} }
func (m *CommonResp) String() string { return proto.CompactTextString(m) } func (m *CommonResp) String() string { return proto.CompactTextString(m) }
func (*CommonResp) ProtoMessage() {} func (*CommonResp) ProtoMessage() {}
func (*CommonResp) Descriptor() ([]byte, []int) { func (*CommonResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{0} return fileDescriptor_admin_cms_521fdb68576e364f, []int{0}
} }
func (m *CommonResp) XXX_Unmarshal(b []byte) error { func (m *CommonResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CommonResp.Unmarshal(m, b) return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@ -83,7 +83,7 @@ func (m *AdminLoginReq) Reset() { *m = AdminLoginReq{} }
func (m *AdminLoginReq) String() string { return proto.CompactTextString(m) } func (m *AdminLoginReq) String() string { return proto.CompactTextString(m) }
func (*AdminLoginReq) ProtoMessage() {} func (*AdminLoginReq) ProtoMessage() {}
func (*AdminLoginReq) Descriptor() ([]byte, []int) { func (*AdminLoginReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{1} return fileDescriptor_admin_cms_521fdb68576e364f, []int{1}
} }
func (m *AdminLoginReq) XXX_Unmarshal(b []byte) error { func (m *AdminLoginReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AdminLoginReq.Unmarshal(m, b) return xxx_messageInfo_AdminLoginReq.Unmarshal(m, b)
@ -136,7 +136,7 @@ func (m *AdminLoginResp) Reset() { *m = AdminLoginResp{} }
func (m *AdminLoginResp) String() string { return proto.CompactTextString(m) } func (m *AdminLoginResp) String() string { return proto.CompactTextString(m) }
func (*AdminLoginResp) ProtoMessage() {} func (*AdminLoginResp) ProtoMessage() {}
func (*AdminLoginResp) Descriptor() ([]byte, []int) { func (*AdminLoginResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{2} return fileDescriptor_admin_cms_521fdb68576e364f, []int{2}
} }
func (m *AdminLoginResp) XXX_Unmarshal(b []byte) error { func (m *AdminLoginResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AdminLoginResp.Unmarshal(m, b) return xxx_messageInfo_AdminLoginResp.Unmarshal(m, b)
@ -182,7 +182,7 @@ func (m *AddUserRegisterAddFriendIDListReq) Reset() { *m = AddUserRegist
func (m *AddUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) } func (m *AddUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) }
func (*AddUserRegisterAddFriendIDListReq) ProtoMessage() {} func (*AddUserRegisterAddFriendIDListReq) ProtoMessage() {}
func (*AddUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) { func (*AddUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{3} return fileDescriptor_admin_cms_521fdb68576e364f, []int{3}
} }
func (m *AddUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error { func (m *AddUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddUserRegisterAddFriendIDListReq.Unmarshal(m, b) return xxx_messageInfo_AddUserRegisterAddFriendIDListReq.Unmarshal(m, b)
@ -227,7 +227,7 @@ func (m *AddUserRegisterAddFriendIDListResp) Reset() { *m = AddUserRegis
func (m *AddUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) } func (m *AddUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) }
func (*AddUserRegisterAddFriendIDListResp) ProtoMessage() {} func (*AddUserRegisterAddFriendIDListResp) ProtoMessage() {}
func (*AddUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) { func (*AddUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{4} return fileDescriptor_admin_cms_521fdb68576e364f, []int{4}
} }
func (m *AddUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error { func (m *AddUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_AddUserRegisterAddFriendIDListResp.Unmarshal(m, b) return xxx_messageInfo_AddUserRegisterAddFriendIDListResp.Unmarshal(m, b)
@ -267,7 +267,7 @@ func (m *ReduceUserRegisterAddFriendIDListReq) Reset() { *m = ReduceUser
func (m *ReduceUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) } func (m *ReduceUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) }
func (*ReduceUserRegisterAddFriendIDListReq) ProtoMessage() {} func (*ReduceUserRegisterAddFriendIDListReq) ProtoMessage() {}
func (*ReduceUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) { func (*ReduceUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{5} return fileDescriptor_admin_cms_521fdb68576e364f, []int{5}
} }
func (m *ReduceUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error { func (m *ReduceUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReduceUserRegisterAddFriendIDListReq.Unmarshal(m, b) return xxx_messageInfo_ReduceUserRegisterAddFriendIDListReq.Unmarshal(m, b)
@ -319,7 +319,7 @@ func (m *ReduceUserRegisterAddFriendIDListResp) Reset() { *m = ReduceUse
func (m *ReduceUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) } func (m *ReduceUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) }
func (*ReduceUserRegisterAddFriendIDListResp) ProtoMessage() {} func (*ReduceUserRegisterAddFriendIDListResp) ProtoMessage() {}
func (*ReduceUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) { func (*ReduceUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{6} return fileDescriptor_admin_cms_521fdb68576e364f, []int{6}
} }
func (m *ReduceUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error { func (m *ReduceUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReduceUserRegisterAddFriendIDListResp.Unmarshal(m, b) return xxx_messageInfo_ReduceUserRegisterAddFriendIDListResp.Unmarshal(m, b)
@ -358,7 +358,7 @@ func (m *GetUserRegisterAddFriendIDListReq) Reset() { *m = GetUserRegist
func (m *GetUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) } func (m *GetUserRegisterAddFriendIDListReq) String() string { return proto.CompactTextString(m) }
func (*GetUserRegisterAddFriendIDListReq) ProtoMessage() {} func (*GetUserRegisterAddFriendIDListReq) ProtoMessage() {}
func (*GetUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) { func (*GetUserRegisterAddFriendIDListReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{7} return fileDescriptor_admin_cms_521fdb68576e364f, []int{7}
} }
func (m *GetUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error { func (m *GetUserRegisterAddFriendIDListReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserRegisterAddFriendIDListReq.Unmarshal(m, b) return xxx_messageInfo_GetUserRegisterAddFriendIDListReq.Unmarshal(m, b)
@ -405,7 +405,7 @@ func (m *GetUserRegisterAddFriendIDListResp) Reset() { *m = GetUserRegis
func (m *GetUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) } func (m *GetUserRegisterAddFriendIDListResp) String() string { return proto.CompactTextString(m) }
func (*GetUserRegisterAddFriendIDListResp) ProtoMessage() {} func (*GetUserRegisterAddFriendIDListResp) ProtoMessage() {}
func (*GetUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) { func (*GetUserRegisterAddFriendIDListResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{8} return fileDescriptor_admin_cms_521fdb68576e364f, []int{8}
} }
func (m *GetUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error { func (m *GetUserRegisterAddFriendIDListResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserRegisterAddFriendIDListResp.Unmarshal(m, b) return xxx_messageInfo_GetUserRegisterAddFriendIDListResp.Unmarshal(m, b)
@ -464,7 +464,7 @@ func (m *GetChatLogsReq) Reset() { *m = GetChatLogsReq{} }
func (m *GetChatLogsReq) String() string { return proto.CompactTextString(m) } func (m *GetChatLogsReq) String() string { return proto.CompactTextString(m) }
func (*GetChatLogsReq) ProtoMessage() {} func (*GetChatLogsReq) ProtoMessage() {}
func (*GetChatLogsReq) Descriptor() ([]byte, []int) { func (*GetChatLogsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{9} return fileDescriptor_admin_cms_521fdb68576e364f, []int{9}
} }
func (m *GetChatLogsReq) XXX_Unmarshal(b []byte) error { func (m *GetChatLogsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetChatLogsReq.Unmarshal(m, b) return xxx_messageInfo_GetChatLogsReq.Unmarshal(m, b)
@ -542,21 +542,23 @@ func (m *GetChatLogsReq) GetOperationID() string {
type ChatLog struct { type ChatLog struct {
ServerMsgID string `protobuf:"bytes,1,opt,name=ServerMsgID" json:"ServerMsgID,omitempty"` ServerMsgID string `protobuf:"bytes,1,opt,name=ServerMsgID" json:"ServerMsgID,omitempty"`
StringClientMsgID string `protobuf:"bytes,2,opt,name=stringClientMsgID" json:"stringClientMsgID,omitempty"` ClientMsgID string `protobuf:"bytes,2,opt,name=ClientMsgID" json:"ClientMsgID,omitempty"`
SendID string `protobuf:"bytes,3,opt,name=SendID" json:"SendID,omitempty"` SendID string `protobuf:"bytes,3,opt,name=SendID" json:"SendID,omitempty"`
RecvID string `protobuf:"bytes,4,opt,name=RecvID" json:"RecvID,omitempty"` RecvID string `protobuf:"bytes,4,opt,name=RecvID" json:"RecvID,omitempty"`
SenderPlatformID int32 `protobuf:"varint,5,opt,name=SenderPlatformID" json:"SenderPlatformID,omitempty"` GroupID string `protobuf:"bytes,5,opt,name=groupID" json:"groupID,omitempty"`
SenderNickname string `protobuf:"bytes,6,opt,name=SenderNickname" json:"SenderNickname,omitempty"` RecvNickname string `protobuf:"bytes,6,opt,name=recvNickname" json:"recvNickname,omitempty"`
SenderFaceURL string `protobuf:"bytes,7,opt,name=SenderFaceURL" json:"SenderFaceURL,omitempty"` SenderPlatformID int32 `protobuf:"varint,7,opt,name=SenderPlatformID" json:"SenderPlatformID,omitempty"`
GroupName string `protobuf:"bytes,8,opt,name=GroupName" json:"GroupName,omitempty"` SenderNickname string `protobuf:"bytes,8,opt,name=SenderNickname" json:"SenderNickname,omitempty"`
SessionType int32 `protobuf:"varint,9,opt,name=SessionType" json:"SessionType,omitempty"` SenderFaceURL string `protobuf:"bytes,9,opt,name=SenderFaceURL" json:"SenderFaceURL,omitempty"`
MsgFrom int32 `protobuf:"varint,10,opt,name=MsgFrom" json:"MsgFrom,omitempty"` GroupName string `protobuf:"bytes,10,opt,name=GroupName" json:"GroupName,omitempty"`
ContentType int32 `protobuf:"varint,11,opt,name=ContentType" json:"ContentType,omitempty"` SessionType int32 `protobuf:"varint,11,opt,name=SessionType" json:"SessionType,omitempty"`
Content string `protobuf:"bytes,12,opt,name=Content" json:"Content,omitempty"` MsgFrom int32 `protobuf:"varint,12,opt,name=MsgFrom" json:"MsgFrom,omitempty"`
Status int32 `protobuf:"varint,13,opt,name=Status" json:"Status,omitempty"` ContentType int32 `protobuf:"varint,13,opt,name=ContentType" json:"ContentType,omitempty"`
SendTime int64 `protobuf:"varint,14,opt,name=SendTime" json:"SendTime,omitempty"` Content string `protobuf:"bytes,14,opt,name=Content" json:"Content,omitempty"`
CreateTime int64 `protobuf:"varint,15,opt,name=CreateTime" json:"CreateTime,omitempty"` Status int32 `protobuf:"varint,15,opt,name=Status" json:"Status,omitempty"`
Ex string `protobuf:"bytes,16,opt,name=Ex" json:"Ex,omitempty"` SendTime int64 `protobuf:"varint,16,opt,name=SendTime" json:"SendTime,omitempty"`
CreateTime int64 `protobuf:"varint,17,opt,name=CreateTime" json:"CreateTime,omitempty"`
Ex string `protobuf:"bytes,18,opt,name=Ex" json:"Ex,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"` XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"` XXX_sizecache int32 `json:"-"`
@ -566,7 +568,7 @@ func (m *ChatLog) Reset() { *m = ChatLog{} }
func (m *ChatLog) String() string { return proto.CompactTextString(m) } func (m *ChatLog) String() string { return proto.CompactTextString(m) }
func (*ChatLog) ProtoMessage() {} func (*ChatLog) ProtoMessage() {}
func (*ChatLog) Descriptor() ([]byte, []int) { func (*ChatLog) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{10} return fileDescriptor_admin_cms_521fdb68576e364f, []int{10}
} }
func (m *ChatLog) XXX_Unmarshal(b []byte) error { func (m *ChatLog) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ChatLog.Unmarshal(m, b) return xxx_messageInfo_ChatLog.Unmarshal(m, b)
@ -593,9 +595,9 @@ func (m *ChatLog) GetServerMsgID() string {
return "" return ""
} }
func (m *ChatLog) GetStringClientMsgID() string { func (m *ChatLog) GetClientMsgID() string {
if m != nil { if m != nil {
return m.StringClientMsgID return m.ClientMsgID
} }
return "" return ""
} }
@ -614,6 +616,20 @@ func (m *ChatLog) GetRecvID() string {
return "" return ""
} }
func (m *ChatLog) GetGroupID() string {
if m != nil {
return m.GroupID
}
return ""
}
func (m *ChatLog) GetRecvNickname() string {
if m != nil {
return m.RecvNickname
}
return ""
}
func (m *ChatLog) GetSenderPlatformID() int32 { func (m *ChatLog) GetSenderPlatformID() int32 {
if m != nil { if m != nil {
return m.SenderPlatformID return m.SenderPlatformID
@ -712,7 +728,7 @@ func (m *GetChatLogsResp) Reset() { *m = GetChatLogsResp{} }
func (m *GetChatLogsResp) String() string { return proto.CompactTextString(m) } func (m *GetChatLogsResp) String() string { return proto.CompactTextString(m) }
func (*GetChatLogsResp) ProtoMessage() {} func (*GetChatLogsResp) ProtoMessage() {}
func (*GetChatLogsResp) Descriptor() ([]byte, []int) { func (*GetChatLogsResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{11} return fileDescriptor_admin_cms_521fdb68576e364f, []int{11}
} }
func (m *GetChatLogsResp) XXX_Unmarshal(b []byte) error { func (m *GetChatLogsResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetChatLogsResp.Unmarshal(m, b) return xxx_messageInfo_GetChatLogsResp.Unmarshal(m, b)
@ -772,7 +788,7 @@ func (m *StatisticsReq) Reset() { *m = StatisticsReq{} }
func (m *StatisticsReq) String() string { return proto.CompactTextString(m) } func (m *StatisticsReq) String() string { return proto.CompactTextString(m) }
func (*StatisticsReq) ProtoMessage() {} func (*StatisticsReq) ProtoMessage() {}
func (*StatisticsReq) Descriptor() ([]byte, []int) { func (*StatisticsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{12} return fileDescriptor_admin_cms_521fdb68576e364f, []int{12}
} }
func (m *StatisticsReq) XXX_Unmarshal(b []byte) error { func (m *StatisticsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_StatisticsReq.Unmarshal(m, b) return xxx_messageInfo_StatisticsReq.Unmarshal(m, b)
@ -818,7 +834,7 @@ func (m *GetActiveUserReq) Reset() { *m = GetActiveUserReq{} }
func (m *GetActiveUserReq) String() string { return proto.CompactTextString(m) } func (m *GetActiveUserReq) String() string { return proto.CompactTextString(m) }
func (*GetActiveUserReq) ProtoMessage() {} func (*GetActiveUserReq) ProtoMessage() {}
func (*GetActiveUserReq) Descriptor() ([]byte, []int) { func (*GetActiveUserReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{13} return fileDescriptor_admin_cms_521fdb68576e364f, []int{13}
} }
func (m *GetActiveUserReq) XXX_Unmarshal(b []byte) error { func (m *GetActiveUserReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetActiveUserReq.Unmarshal(m, b) return xxx_messageInfo_GetActiveUserReq.Unmarshal(m, b)
@ -865,7 +881,7 @@ func (m *UserResp) Reset() { *m = UserResp{} }
func (m *UserResp) String() string { return proto.CompactTextString(m) } func (m *UserResp) String() string { return proto.CompactTextString(m) }
func (*UserResp) ProtoMessage() {} func (*UserResp) ProtoMessage() {}
func (*UserResp) Descriptor() ([]byte, []int) { func (*UserResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{14} return fileDescriptor_admin_cms_521fdb68576e364f, []int{14}
} }
func (m *UserResp) XXX_Unmarshal(b []byte) error { func (m *UserResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_UserResp.Unmarshal(m, b) return xxx_messageInfo_UserResp.Unmarshal(m, b)
@ -918,7 +934,7 @@ func (m *GetActiveUserResp) Reset() { *m = GetActiveUserResp{} }
func (m *GetActiveUserResp) String() string { return proto.CompactTextString(m) } func (m *GetActiveUserResp) String() string { return proto.CompactTextString(m) }
func (*GetActiveUserResp) ProtoMessage() {} func (*GetActiveUserResp) ProtoMessage() {}
func (*GetActiveUserResp) Descriptor() ([]byte, []int) { func (*GetActiveUserResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{15} return fileDescriptor_admin_cms_521fdb68576e364f, []int{15}
} }
func (m *GetActiveUserResp) XXX_Unmarshal(b []byte) error { func (m *GetActiveUserResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetActiveUserResp.Unmarshal(m, b) return xxx_messageInfo_GetActiveUserResp.Unmarshal(m, b)
@ -964,7 +980,7 @@ func (m *GetActiveGroupReq) Reset() { *m = GetActiveGroupReq{} }
func (m *GetActiveGroupReq) String() string { return proto.CompactTextString(m) } func (m *GetActiveGroupReq) String() string { return proto.CompactTextString(m) }
func (*GetActiveGroupReq) ProtoMessage() {} func (*GetActiveGroupReq) ProtoMessage() {}
func (*GetActiveGroupReq) Descriptor() ([]byte, []int) { func (*GetActiveGroupReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{16} return fileDescriptor_admin_cms_521fdb68576e364f, []int{16}
} }
func (m *GetActiveGroupReq) XXX_Unmarshal(b []byte) error { func (m *GetActiveGroupReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetActiveGroupReq.Unmarshal(m, b) return xxx_messageInfo_GetActiveGroupReq.Unmarshal(m, b)
@ -1012,7 +1028,7 @@ func (m *GroupResp) Reset() { *m = GroupResp{} }
func (m *GroupResp) String() string { return proto.CompactTextString(m) } func (m *GroupResp) String() string { return proto.CompactTextString(m) }
func (*GroupResp) ProtoMessage() {} func (*GroupResp) ProtoMessage() {}
func (*GroupResp) Descriptor() ([]byte, []int) { func (*GroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{17} return fileDescriptor_admin_cms_521fdb68576e364f, []int{17}
} }
func (m *GroupResp) XXX_Unmarshal(b []byte) error { func (m *GroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GroupResp.Unmarshal(m, b) return xxx_messageInfo_GroupResp.Unmarshal(m, b)
@ -1072,7 +1088,7 @@ func (m *GetActiveGroupResp) Reset() { *m = GetActiveGroupResp{} }
func (m *GetActiveGroupResp) String() string { return proto.CompactTextString(m) } func (m *GetActiveGroupResp) String() string { return proto.CompactTextString(m) }
func (*GetActiveGroupResp) ProtoMessage() {} func (*GetActiveGroupResp) ProtoMessage() {}
func (*GetActiveGroupResp) Descriptor() ([]byte, []int) { func (*GetActiveGroupResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{18} return fileDescriptor_admin_cms_521fdb68576e364f, []int{18}
} }
func (m *GetActiveGroupResp) XXX_Unmarshal(b []byte) error { func (m *GetActiveGroupResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetActiveGroupResp.Unmarshal(m, b) return xxx_messageInfo_GetActiveGroupResp.Unmarshal(m, b)
@ -1118,7 +1134,7 @@ func (m *DateNumList) Reset() { *m = DateNumList{} }
func (m *DateNumList) String() string { return proto.CompactTextString(m) } func (m *DateNumList) String() string { return proto.CompactTextString(m) }
func (*DateNumList) ProtoMessage() {} func (*DateNumList) ProtoMessage() {}
func (*DateNumList) Descriptor() ([]byte, []int) { func (*DateNumList) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{19} return fileDescriptor_admin_cms_521fdb68576e364f, []int{19}
} }
func (m *DateNumList) XXX_Unmarshal(b []byte) error { func (m *DateNumList) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DateNumList.Unmarshal(m, b) return xxx_messageInfo_DateNumList.Unmarshal(m, b)
@ -1164,7 +1180,7 @@ func (m *GetMessageStatisticsReq) Reset() { *m = GetMessageStatisticsReq
func (m *GetMessageStatisticsReq) String() string { return proto.CompactTextString(m) } func (m *GetMessageStatisticsReq) String() string { return proto.CompactTextString(m) }
func (*GetMessageStatisticsReq) ProtoMessage() {} func (*GetMessageStatisticsReq) ProtoMessage() {}
func (*GetMessageStatisticsReq) Descriptor() ([]byte, []int) { func (*GetMessageStatisticsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{20} return fileDescriptor_admin_cms_521fdb68576e364f, []int{20}
} }
func (m *GetMessageStatisticsReq) XXX_Unmarshal(b []byte) error { func (m *GetMessageStatisticsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMessageStatisticsReq.Unmarshal(m, b) return xxx_messageInfo_GetMessageStatisticsReq.Unmarshal(m, b)
@ -1213,7 +1229,7 @@ func (m *GetMessageStatisticsResp) Reset() { *m = GetMessageStatisticsRe
func (m *GetMessageStatisticsResp) String() string { return proto.CompactTextString(m) } func (m *GetMessageStatisticsResp) String() string { return proto.CompactTextString(m) }
func (*GetMessageStatisticsResp) ProtoMessage() {} func (*GetMessageStatisticsResp) ProtoMessage() {}
func (*GetMessageStatisticsResp) Descriptor() ([]byte, []int) { func (*GetMessageStatisticsResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{21} return fileDescriptor_admin_cms_521fdb68576e364f, []int{21}
} }
func (m *GetMessageStatisticsResp) XXX_Unmarshal(b []byte) error { func (m *GetMessageStatisticsResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetMessageStatisticsResp.Unmarshal(m, b) return xxx_messageInfo_GetMessageStatisticsResp.Unmarshal(m, b)
@ -1280,7 +1296,7 @@ func (m *GetGroupStatisticsReq) Reset() { *m = GetGroupStatisticsReq{} }
func (m *GetGroupStatisticsReq) String() string { return proto.CompactTextString(m) } func (m *GetGroupStatisticsReq) String() string { return proto.CompactTextString(m) }
func (*GetGroupStatisticsReq) ProtoMessage() {} func (*GetGroupStatisticsReq) ProtoMessage() {}
func (*GetGroupStatisticsReq) Descriptor() ([]byte, []int) { func (*GetGroupStatisticsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{22} return fileDescriptor_admin_cms_521fdb68576e364f, []int{22}
} }
func (m *GetGroupStatisticsReq) XXX_Unmarshal(b []byte) error { func (m *GetGroupStatisticsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupStatisticsReq.Unmarshal(m, b) return xxx_messageInfo_GetGroupStatisticsReq.Unmarshal(m, b)
@ -1329,7 +1345,7 @@ func (m *GetGroupStatisticsResp) Reset() { *m = GetGroupStatisticsResp{}
func (m *GetGroupStatisticsResp) String() string { return proto.CompactTextString(m) } func (m *GetGroupStatisticsResp) String() string { return proto.CompactTextString(m) }
func (*GetGroupStatisticsResp) ProtoMessage() {} func (*GetGroupStatisticsResp) ProtoMessage() {}
func (*GetGroupStatisticsResp) Descriptor() ([]byte, []int) { func (*GetGroupStatisticsResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{23} return fileDescriptor_admin_cms_521fdb68576e364f, []int{23}
} }
func (m *GetGroupStatisticsResp) XXX_Unmarshal(b []byte) error { func (m *GetGroupStatisticsResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetGroupStatisticsResp.Unmarshal(m, b) return xxx_messageInfo_GetGroupStatisticsResp.Unmarshal(m, b)
@ -1396,7 +1412,7 @@ func (m *GetUserStatisticsReq) Reset() { *m = GetUserStatisticsReq{} }
func (m *GetUserStatisticsReq) String() string { return proto.CompactTextString(m) } func (m *GetUserStatisticsReq) String() string { return proto.CompactTextString(m) }
func (*GetUserStatisticsReq) ProtoMessage() {} func (*GetUserStatisticsReq) ProtoMessage() {}
func (*GetUserStatisticsReq) Descriptor() ([]byte, []int) { func (*GetUserStatisticsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{24} return fileDescriptor_admin_cms_521fdb68576e364f, []int{24}
} }
func (m *GetUserStatisticsReq) XXX_Unmarshal(b []byte) error { func (m *GetUserStatisticsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserStatisticsReq.Unmarshal(m, b) return xxx_messageInfo_GetUserStatisticsReq.Unmarshal(m, b)
@ -1447,7 +1463,7 @@ func (m *GetUserStatisticsResp) Reset() { *m = GetUserStatisticsResp{} }
func (m *GetUserStatisticsResp) String() string { return proto.CompactTextString(m) } func (m *GetUserStatisticsResp) String() string { return proto.CompactTextString(m) }
func (*GetUserStatisticsResp) ProtoMessage() {} func (*GetUserStatisticsResp) ProtoMessage() {}
func (*GetUserStatisticsResp) Descriptor() ([]byte, []int) { func (*GetUserStatisticsResp) Descriptor() ([]byte, []int) {
return fileDescriptor_admin_cms_a6bac7cb5a282446, []int{25} return fileDescriptor_admin_cms_521fdb68576e364f, []int{25}
} }
func (m *GetUserStatisticsResp) XXX_Unmarshal(b []byte) error { func (m *GetUserStatisticsResp) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_GetUserStatisticsResp.Unmarshal(m, b) return xxx_messageInfo_GetUserStatisticsResp.Unmarshal(m, b)
@ -1915,98 +1931,99 @@ var _AdminCMS_serviceDesc = grpc.ServiceDesc{
} }
func init() { func init() {
proto.RegisterFile("admin_cms/admin_cms.proto", fileDescriptor_admin_cms_a6bac7cb5a282446) proto.RegisterFile("admin_cms/admin_cms.proto", fileDescriptor_admin_cms_521fdb68576e364f)
} }
var fileDescriptor_admin_cms_a6bac7cb5a282446 = []byte{ var fileDescriptor_admin_cms_521fdb68576e364f = []byte{
// 1416 bytes of a gzipped FileDescriptorProto // 1436 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xcd, 0x6e, 0xdb, 0xc6, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdd, 0x6e, 0x13, 0xc7,
0x13, 0x07, 0x25, 0xcb, 0xb2, 0x46, 0xb1, 0x63, 0x6f, 0xec, 0x84, 0x51, 0xf2, 0xcf, 0x5f, 0x66, 0x17, 0xd7, 0xda, 0x71, 0x1c, 0x1f, 0x93, 0x90, 0x1c, 0x12, 0x58, 0x0c, 0x7f, 0xfe, 0xce, 0x16,
0x93, 0x42, 0x2d, 0x52, 0xa9, 0x70, 0xd0, 0x53, 0x81, 0x14, 0x8e, 0x94, 0xa8, 0x0a, 0xac, 0xc4, 0xaa, 0xb4, 0xa2, 0x49, 0x15, 0xd4, 0xab, 0x4a, 0x54, 0x21, 0x86, 0xd4, 0x28, 0x86, 0x68, 0x81,
0x60, 0x92, 0x02, 0x6d, 0xd1, 0x08, 0xac, 0xb4, 0x56, 0x09, 0x5b, 0xe4, 0x9a, 0xbb, 0x72, 0x1c, 0x4a, 0x6d, 0x55, 0xac, 0xad, 0x3d, 0xb8, 0xab, 0xe0, 0xdd, 0x61, 0x67, 0x1c, 0x40, 0x55, 0x6f,
0x14, 0xbd, 0xe6, 0xd2, 0x7b, 0x0f, 0x3d, 0xf6, 0x15, 0xfa, 0x04, 0x3d, 0xf6, 0x31, 0x8a, 0x3e, 0xb9, 0xe9, 0x7d, 0x2f, 0x7a, 0xd9, 0x17, 0xe8, 0x45, 0x9f, 0xa0, 0x97, 0x7d, 0x8c, 0xaa, 0x2f,
0x47, 0x81, 0x62, 0x77, 0xf9, 0xb1, 0x4b, 0xd2, 0x92, 0xec, 0xa0, 0xbe, 0x71, 0x66, 0xe7, 0x63, 0x52, 0xcd, 0xcc, 0x7e, 0xcc, 0xec, 0x6e, 0x6c, 0x13, 0x54, 0xee, 0xe6, 0x9c, 0x39, 0x1f, 0x73,
0xe7, 0xf7, 0x9b, 0x59, 0x2e, 0x09, 0x37, 0x9d, 0xd1, 0xc4, 0xf5, 0x06, 0xc3, 0x09, 0x6d, 0xc5, 0x7e, 0xe7, 0x63, 0x66, 0x17, 0x2e, 0x7b, 0xc3, 0xb1, 0x1f, 0xf4, 0x07, 0x63, 0xb6, 0x93, 0xae,
0x4f, 0x4d, 0x12, 0xf8, 0xcc, 0x47, 0x95, 0x58, 0x51, 0xdb, 0x7e, 0x4e, 0xb0, 0x37, 0xe8, 0xf5, 0xb6, 0x69, 0x14, 0xf2, 0x10, 0x1b, 0x29, 0xa3, 0xb5, 0xf9, 0x90, 0x92, 0xa0, 0xdf, 0xed, 0xed,
0x5b, 0xe4, 0x70, 0xdc, 0x12, 0xab, 0x2d, 0x3a, 0x3a, 0x1c, 0xbc, 0xa1, 0xad, 0x37, 0xa1, 0xb5, 0xd0, 0xe3, 0xd1, 0x8e, 0xdc, 0xdd, 0x61, 0xc3, 0xe3, 0xfe, 0x4b, 0xb6, 0xf3, 0x32, 0x96, 0x76,
0xf5, 0x10, 0xa0, 0xed, 0x4f, 0x26, 0xbe, 0x67, 0x63, 0x4a, 0x90, 0x09, 0x65, 0x1c, 0x04, 0x6d, 0x6e, 0x03, 0xec, 0x87, 0xe3, 0x71, 0x18, 0xb8, 0x84, 0x51, 0xb4, 0xa1, 0x4e, 0xa2, 0x68, 0x3f,
0x7f, 0x84, 0x4d, 0xa3, 0x6e, 0x34, 0x4a, 0x76, 0x24, 0xa2, 0xeb, 0xb0, 0x8c, 0x83, 0xa0, 0x4f, 0x1c, 0x12, 0xdb, 0x6a, 0x5b, 0x5b, 0x35, 0x37, 0x21, 0xf1, 0x22, 0x2c, 0x92, 0x28, 0xea, 0xb1,
0xc7, 0x66, 0xa1, 0x6e, 0x34, 0x2a, 0x76, 0x28, 0x59, 0x43, 0x58, 0xdd, 0xe5, 0xf9, 0xf6, 0xfc, 0x91, 0x5d, 0x69, 0x5b, 0x5b, 0x0d, 0x37, 0xa6, 0x9c, 0x01, 0x2c, 0xef, 0x09, 0x7f, 0x87, 0xe1,
0xb1, 0xeb, 0xd9, 0xf8, 0x18, 0xd5, 0xa1, 0xfa, 0x9c, 0xe0, 0xc0, 0x61, 0xae, 0xef, 0xf5, 0x3a, 0xc8, 0x0f, 0x5c, 0xf2, 0x02, 0xdb, 0xd0, 0x7c, 0x48, 0x49, 0xe4, 0x71, 0x3f, 0x0c, 0xba, 0x1d,
0x22, 0x4c, 0xc5, 0x56, 0x55, 0x3c, 0x89, 0x70, 0xe9, 0x75, 0xc2, 0x58, 0x91, 0xc8, 0x93, 0xbc, 0x69, 0xa6, 0xe1, 0xea, 0x2c, 0xe1, 0x44, 0xaa, 0x74, 0x3b, 0xb1, 0xad, 0x84, 0x14, 0x4e, 0x1e,
0xc0, 0xc3, 0x00, 0x33, 0xb3, 0x28, 0x93, 0x48, 0xc9, 0xfa, 0x0e, 0xd6, 0xd4, 0x24, 0x94, 0xa0, 0x91, 0x41, 0x44, 0xb8, 0x5d, 0x55, 0x4e, 0x14, 0xe5, 0x7c, 0x07, 0x2b, 0xba, 0x13, 0x46, 0x71,
0x4d, 0x28, 0x31, 0xff, 0x10, 0x7b, 0x61, 0x7c, 0x29, 0xa0, 0xcf, 0x00, 0x86, 0x71, 0x31, 0x22, 0x1d, 0x6a, 0x3c, 0x3c, 0x26, 0x41, 0x6c, 0x5f, 0x11, 0xf8, 0x19, 0xc0, 0x20, 0x0d, 0x46, 0x1a,
0x78, 0x75, 0x67, 0xab, 0x99, 0x00, 0x94, 0x54, 0x6a, 0x2b, 0x86, 0x16, 0x86, 0xed, 0xdd, 0xd1, 0x6f, 0xee, 0x6e, 0x6c, 0x67, 0x00, 0x65, 0x91, 0xba, 0x9a, 0xa0, 0x43, 0x60, 0x73, 0x6f, 0x38,
0xe8, 0x15, 0xc5, 0x81, 0x8d, 0xc7, 0x2e, 0x65, 0x38, 0xd8, 0x1d, 0x8d, 0x9e, 0x04, 0x2e, 0xf6, 0x7c, 0xc2, 0x48, 0xe4, 0x92, 0x91, 0xcf, 0x38, 0x89, 0xf6, 0x86, 0xc3, 0x7b, 0x91, 0x4f, 0x82,
0x46, 0xbd, 0xce, 0x9e, 0x4b, 0x59, 0x58, 0x97, 0x9f, 0xad, 0x4b, 0x51, 0xa1, 0x3b, 0x00, 0x53, 0x61, 0xb7, 0x73, 0xe8, 0x33, 0x1e, 0xc7, 0x15, 0x16, 0xe3, 0xd2, 0x58, 0x78, 0x0d, 0x60, 0xc2,
0x8a, 0x03, 0xe9, 0x62, 0x16, 0xea, 0xc5, 0x46, 0xc5, 0x56, 0x34, 0xd6, 0xb7, 0x60, 0xcd, 0x4b, 0x48, 0xa4, 0x54, 0xec, 0x4a, 0xbb, 0xba, 0xd5, 0x70, 0x35, 0x8e, 0xf3, 0x2d, 0x38, 0xb3, 0xdc,
0x43, 0x49, 0xaa, 0x06, 0x63, 0xd1, 0x1a, 0xde, 0x19, 0x70, 0xd7, 0xc6, 0xa3, 0xe9, 0x10, 0xbf, 0x30, 0x9a, 0x8b, 0xc1, 0x9a, 0x37, 0x86, 0x37, 0x16, 0x5c, 0x77, 0xc9, 0x70, 0x32, 0x20, 0xef,
0x77, 0x1d, 0xb7, 0xa1, 0x12, 0x8b, 0x02, 0xc4, 0x92, 0x9d, 0x28, 0x52, 0x55, 0x16, 0x33, 0x55, 0x1c, 0xc7, 0x55, 0x68, 0xa4, 0xa4, 0x04, 0xb1, 0xe6, 0x66, 0x8c, 0x5c, 0x94, 0xd5, 0x42, 0x94,
0xbe, 0x86, 0x7b, 0x0b, 0xec, 0xe3, 0xe2, 0x85, 0xfe, 0x6c, 0xc0, 0x76, 0x17, 0xb3, 0xf7, 0xae, 0x4f, 0xe1, 0xc6, 0x1c, 0xe7, 0x38, 0x7b, 0xa0, 0x3f, 0x5b, 0xb0, 0x79, 0x40, 0xf8, 0x3b, 0x47,
0xb2, 0x03, 0x40, 0x9c, 0xb1, 0xeb, 0x25, 0x65, 0x56, 0x77, 0xee, 0x36, 0x29, 0x0e, 0x4e, 0x70, 0xd9, 0x01, 0xa0, 0xde, 0xc8, 0x0f, 0xb2, 0x30, 0x9b, 0xbb, 0xd7, 0xb7, 0x19, 0x89, 0x4e, 0x48,
0x30, 0x70, 0x88, 0x3b, 0x20, 0x4e, 0xe0, 0x4c, 0x68, 0xd3, 0xc6, 0xc7, 0x53, 0x4c, 0xd9, 0x7e, 0xd4, 0xf7, 0xa8, 0xdf, 0xa7, 0x5e, 0xe4, 0x8d, 0xd9, 0xb6, 0x4b, 0x5e, 0x4c, 0x08, 0xe3, 0x47,
0x6c, 0x6b, 0x2b, 0x7e, 0xd6, 0xdf, 0x06, 0x58, 0xf3, 0x76, 0x43, 0x09, 0xfa, 0x02, 0xae, 0x08, 0xa9, 0xac, 0xab, 0xe9, 0x39, 0xff, 0x58, 0xe0, 0xcc, 0x3a, 0x0d, 0xa3, 0xf8, 0x05, 0x9c, 0x93,
0x88, 0xbc, 0x03, 0x5f, 0xc0, 0x66, 0xd4, 0x8b, 0x8d, 0xea, 0xce, 0xad, 0x9c, 0x74, 0xaf, 0x42, 0x10, 0x05, 0xcf, 0x42, 0x09, 0x9b, 0xd5, 0xae, 0x6e, 0x35, 0x77, 0xaf, 0x94, 0xb8, 0x7b, 0x12,
0x33, 0x5b, 0x73, 0x40, 0x8f, 0x73, 0x76, 0x7b, 0x2f, 0x77, 0xb7, 0x94, 0xf8, 0x1e, 0xc5, 0xf9, 0x8b, 0xb9, 0x86, 0x02, 0xde, 0x2d, 0x39, 0xed, 0x8d, 0xd2, 0xd3, 0x32, 0x1a, 0x06, 0x8c, 0x94,
0xdb, 0x4d, 0x61, 0x5e, 0x5c, 0x14, 0xf3, 0xdf, 0x0a, 0xb0, 0xd6, 0xc5, 0xac, 0xfd, 0x83, 0xc3, 0x1f, 0x37, 0x87, 0x79, 0x75, 0x5e, 0xcc, 0x7f, 0xab, 0xc0, 0xca, 0x01, 0xe1, 0xfb, 0x3f, 0x78,
0xf6, 0xfc, 0x31, 0xe5, 0x00, 0x9b, 0x50, 0x6e, 0xfb, 0x1e, 0xc3, 0x1e, 0x0b, 0xc1, 0x8d, 0x44, 0xfc, 0x30, 0x1c, 0x31, 0x01, 0xb0, 0x0d, 0xf5, 0xfd, 0x30, 0xe0, 0x24, 0xe0, 0x31, 0xb8, 0x09,
0x39, 0xc4, 0xbc, 0xfa, 0xe8, 0xa4, 0x90, 0x12, 0xd7, 0xdb, 0x78, 0x78, 0xd2, 0xeb, 0x44, 0xc3, 0xa9, 0x9a, 0x58, 0x44, 0x9f, 0x4c, 0x0a, 0x45, 0x09, 0xbe, 0x4b, 0x06, 0x27, 0xdd, 0x4e, 0xd2,
0x2d, 0x25, 0x54, 0x83, 0x15, 0x6e, 0xf1, 0xd2, 0x9d, 0x60, 0x73, 0x49, 0xac, 0xc4, 0x32, 0xa7, 0xdc, 0x8a, 0xc2, 0x16, 0x2c, 0x09, 0x89, 0xc7, 0xfe, 0x98, 0xd8, 0x0b, 0x72, 0x27, 0xa5, 0x45,
0xf1, 0x05, 0xa6, 0xd4, 0xf5, 0xbd, 0x97, 0x6f, 0x09, 0x36, 0x4b, 0xa2, 0x19, 0x55, 0x15, 0xb7, 0x1a, 0x1f, 0x11, 0xc6, 0xfc, 0x30, 0x78, 0xfc, 0x9a, 0x12, 0xbb, 0x26, 0x8b, 0x51, 0x67, 0x09,
0x08, 0x13, 0x0b, 0x8b, 0x65, 0x69, 0xa1, 0xa8, 0x38, 0xd1, 0x09, 0x1a, 0x66, 0xf9, 0x3c, 0x44, 0x89, 0xd8, 0xb1, 0x94, 0x58, 0x54, 0x12, 0x1a, 0x4b, 0x24, 0x3a, 0x43, 0xc3, 0xae, 0xbf, 0x4d,
0x27, 0xcf, 0xe9, 0x63, 0x6d, 0x25, 0x73, 0xac, 0x59, 0xff, 0x14, 0xa1, 0x1c, 0x22, 0x24, 0xf7, 0xa2, 0xb3, 0x75, 0x7e, 0xac, 0x2d, 0x15, 0xc6, 0x9a, 0xf3, 0xfb, 0x02, 0xd4, 0x63, 0x84, 0xd4,
0xcd, 0x13, 0xf4, 0xe9, 0x38, 0x69, 0x3f, 0x45, 0x85, 0xee, 0xc3, 0x06, 0x65, 0x81, 0xeb, 0x8d, 0xb9, 0x85, 0x83, 0x1e, 0x1b, 0x65, 0xe5, 0xa7, 0xb1, 0xe4, 0xb9, 0x9f, 0xfb, 0x24, 0xe0, 0x4a,
0xdb, 0x47, 0x2e, 0xf6, 0x98, 0xb4, 0x93, 0x80, 0x65, 0x17, 0x14, 0x4c, 0x8b, 0x67, 0x60, 0xba, 0x42, 0x41, 0xa5, 0xb3, 0x34, 0x1c, 0xab, 0xa7, 0xe0, 0xb8, 0x60, 0xe0, 0x68, 0x43, 0x7d, 0x14,
0xa4, 0x61, 0xfa, 0x31, 0xac, 0x73, 0x0b, 0x1c, 0xec, 0x1f, 0x39, 0xec, 0xc0, 0x0f, 0x26, 0xbd, 0x85, 0x13, 0xda, 0xed, 0x48, 0x9c, 0x1a, 0x6e, 0x42, 0xa2, 0x03, 0xe7, 0x22, 0x32, 0x38, 0x79,
0x4e, 0x08, 0x5e, 0x46, 0x8f, 0x3e, 0x84, 0x35, 0xa9, 0x7b, 0xe6, 0x0e, 0x0f, 0x3d, 0x67, 0x22, 0xe0, 0x0f, 0x8e, 0x03, 0x6f, 0xac, 0x40, 0x6a, 0xb8, 0x06, 0x0f, 0x3f, 0x86, 0x55, 0x61, 0x9f,
0x41, 0xac, 0xd8, 0x29, 0x2d, 0xba, 0x0b, 0xab, 0x52, 0xf3, 0xc4, 0x19, 0xe2, 0x57, 0xf6, 0x9e, 0x44, 0x47, 0xcf, 0x3d, 0xfe, 0x2c, 0x8c, 0xc6, 0xdd, 0x8e, 0xc4, 0xaa, 0xe6, 0x16, 0xf8, 0xf8,
0x80, 0xb2, 0x62, 0xeb, 0x4a, 0x7e, 0x78, 0x74, 0x03, 0x7f, 0x4a, 0x9e, 0xf1, 0x40, 0x12, 0xa5, 0x21, 0xac, 0x28, 0x5e, 0x6a, 0x51, 0xc1, 0x91, 0xe3, 0xe2, 0x75, 0x58, 0x56, 0x9c, 0x7b, 0xde,
0x44, 0x91, 0xe6, 0xb3, 0x92, 0xe5, 0xd3, 0x84, 0x72, 0x9f, 0x8e, 0x9f, 0x04, 0xfe, 0xc4, 0x04, 0x80, 0x3c, 0x71, 0x0f, 0xed, 0x86, 0x14, 0x33, 0x99, 0x62, 0xdc, 0x1c, 0x88, 0x83, 0x3e, 0x10,
0xf9, 0x06, 0x0a, 0xc5, 0x34, 0xd3, 0xd5, 0x2c, 0xd3, 0x4a, 0x4f, 0x5e, 0xc9, 0xf6, 0x24, 0x73, 0x86, 0x40, 0x4a, 0x64, 0x8c, 0x7c, 0x05, 0x34, 0x8b, 0x15, 0x60, 0x43, 0xbd, 0xc7, 0x46, 0xf7,
0xd8, 0x94, 0x9a, 0xab, 0xc2, 0x2d, 0x94, 0xb4, 0xde, 0x5b, 0xab, 0x1b, 0x8d, 0xa2, 0xd2, 0x7b, 0xa2, 0x70, 0x6c, 0x9f, 0x53, 0x77, 0x56, 0x4c, 0xe6, 0x6b, 0x63, 0xb9, 0x58, 0x1b, 0x5a, 0x15,
0x77, 0x00, 0xda, 0x01, 0x76, 0x18, 0x16, 0xab, 0x57, 0xc5, 0xaa, 0xa2, 0x41, 0x6b, 0x50, 0x78, 0xaf, 0x14, 0xab, 0x98, 0x7b, 0x7c, 0xc2, 0xec, 0xf3, 0x52, 0x2d, 0xa6, 0x8c, 0x6a, 0x5d, 0x6d,
0x7c, 0x6a, 0xae, 0x8b, 0x44, 0x85, 0xc7, 0xa7, 0xd6, 0x5f, 0x06, 0x5c, 0xd5, 0x86, 0x84, 0x12, 0x5b, 0x5b, 0x55, 0xad, 0x5a, 0xaf, 0x01, 0xec, 0x47, 0xc4, 0xe3, 0x44, 0xee, 0xae, 0xc9, 0x5d,
0xd4, 0x84, 0x95, 0x48, 0x0e, 0x67, 0x1e, 0xa9, 0xd3, 0x26, 0x97, 0xec, 0xd8, 0x86, 0x8f, 0xf9, 0x8d, 0x83, 0x2b, 0x50, 0xb9, 0xfb, 0xca, 0x46, 0xe9, 0xa8, 0x72, 0xf7, 0x95, 0xf3, 0xb7, 0x05,
0xfe, 0x45, 0xc7, 0x5c, 0x6f, 0xd6, 0x28, 0xe4, 0xb3, 0xe9, 0x44, 0xf4, 0x0c, 0x87, 0x2a, 0x51, 0xe7, 0x8d, 0xb6, 0x62, 0x14, 0xb7, 0x61, 0x29, 0xa1, 0xe3, 0x29, 0x81, 0x7a, 0x7f, 0xaa, 0x2d,
0xf1, 0x83, 0x20, 0x99, 0x75, 0xd1, 0x3c, 0x67, 0x1f, 0x04, 0xc9, 0xb3, 0xf5, 0x00, 0x56, 0x39, 0x37, 0x95, 0x11, 0x83, 0xe1, 0xe8, 0xac, 0x83, 0xc1, 0x2c, 0xef, 0xc4, 0xe4, 0x83, 0xc9, 0x58,
0x72, 0x2e, 0x65, 0xee, 0x50, 0x1c, 0x03, 0x08, 0x96, 0x0e, 0x38, 0x57, 0xb2, 0xc3, 0xc5, 0x33, 0x56, 0x9c, 0x80, 0x2a, 0x63, 0x89, 0xd1, 0x91, 0x4d, 0x07, 0x59, 0x7a, 0xa7, 0x8f, 0x8e, 0x6c,
0x07, 0x86, 0xf9, 0x61, 0x2f, 0x17, 0x98, 0x6f, 0x31, 0x58, 0xef, 0x62, 0xb6, 0x3b, 0x64, 0xee, 0xed, 0xdc, 0x82, 0x65, 0x81, 0x9c, 0xcf, 0xb8, 0x3f, 0x90, 0x83, 0x03, 0x61, 0xe1, 0x99, 0xc8,
0x49, 0xf8, 0x52, 0x38, 0x46, 0x0f, 0x53, 0x81, 0xc2, 0xf3, 0xdf, 0x54, 0xb6, 0xa0, 0xad, 0xdb, 0x95, 0xea, 0x09, 0xb9, 0x16, 0xc0, 0xf0, 0x30, 0xee, 0x81, 0x0a, 0x0f, 0x1d, 0x0e, 0xab, 0x07,
0xa9, 0xbc, 0xa9, 0x71, 0x2c, 0x64, 0xc7, 0xf1, 0x35, 0xac, 0xc8, 0x64, 0x94, 0x70, 0x9a, 0x79, 0x84, 0xef, 0x0d, 0xb8, 0x7f, 0x12, 0x5f, 0x23, 0x2f, 0xf0, 0x76, 0xce, 0x50, 0x7c, 0x63, 0xd8,
0x1b, 0x8b, 0x9e, 0x94, 0x3b, 0x8d, 0x65, 0xde, 0x1a, 0xe2, 0xcc, 0x1d, 0x45, 0xc7, 0x95, 0x94, 0xda, 0x11, 0x8c, 0x7d, 0x37, 0xe7, 0x37, 0xd7, 0xc0, 0x95, 0x62, 0x03, 0x3f, 0x85, 0x25, 0xe5,
0x38, 0xfd, 0x7d, 0x4c, 0xa9, 0x33, 0xc6, 0x09, 0x84, 0x8a, 0xc6, 0x9a, 0xc2, 0x46, 0xaa, 0x2a, 0x8c, 0x51, 0x91, 0x66, 0x51, 0xc6, 0xb2, 0x26, 0xd5, 0x49, 0x53, 0x5a, 0x94, 0x86, 0x9c, 0xd2,
0x4a, 0xd0, 0x47, 0x50, 0xe2, 0xcf, 0x11, 0xd9, 0xd7, 0x94, 0x72, 0x22, 0x1b, 0x5b, 0x5a, 0xa4, 0xc3, 0x64, 0xc0, 0x29, 0x4a, 0xa4, 0xbf, 0x47, 0x18, 0xf3, 0x46, 0x24, 0x83, 0x50, 0xe3, 0x38,
0x18, 0x28, 0x2c, 0xca, 0x80, 0x9a, 0x56, 0xcc, 0xd5, 0xe5, 0xa0, 0xf9, 0xab, 0x11, 0xce, 0xb5, 0x13, 0x58, 0xcb, 0x45, 0xc5, 0x28, 0x7e, 0x04, 0x35, 0xb1, 0x4e, 0x92, 0x7d, 0x41, 0x0b, 0x27,
0x28, 0x53, 0x1b, 0x72, 0x23, 0x3d, 0xe4, 0x26, 0x94, 0x85, 0x10, 0x43, 0x1a, 0x89, 0xf3, 0x30, 0x91, 0x71, 0x95, 0x44, 0x2e, 0x03, 0x95, 0x79, 0x33, 0xa0, 0xbb, 0x95, 0x7d, 0xf5, 0x7e, 0xd0,
0xbd, 0x68, 0x57, 0xbe, 0x05, 0x94, 0xc6, 0x84, 0x12, 0x74, 0x1f, 0x96, 0x85, 0x10, 0x91, 0xb1, 0xfc, 0xd5, 0x8a, 0xfb, 0x5a, 0x86, 0x69, 0x34, 0xb9, 0x95, 0x6f, 0x72, 0x1b, 0xea, 0x92, 0x48,
0xa9, 0x04, 0x8a, 0xad, 0xec, 0xd0, 0xe6, 0xa2, 0x74, 0x3c, 0x80, 0x6a, 0xc7, 0x61, 0x7c, 0xf3, 0x21, 0x4d, 0xc8, 0x59, 0x98, 0x9e, 0xb5, 0x2a, 0x5f, 0x03, 0xe6, 0x31, 0x61, 0x14, 0x6f, 0xc2,
0xe2, 0x35, 0x8d, 0x60, 0x89, 0x8b, 0xd1, 0x38, 0xf0, 0x67, 0xb4, 0x0e, 0x45, 0x5e, 0xad, 0xbc, 0xa2, 0x24, 0x92, 0x64, 0xac, 0x6b, 0x86, 0x52, 0x29, 0x37, 0x96, 0x39, 0x6b, 0x3a, 0x6e, 0x41,
0x48, 0xf1, 0x47, 0xeb, 0x47, 0xb8, 0xd1, 0xc5, 0x2c, 0xac, 0x5b, 0x67, 0xe2, 0xbf, 0x67, 0xf2, 0xb3, 0xe3, 0x71, 0x71, 0x78, 0x79, 0xb1, 0x23, 0x2c, 0x08, 0x32, 0x69, 0x07, 0xb1, 0xc6, 0x55,
0x8f, 0x02, 0x98, 0xf9, 0xd9, 0x05, 0x66, 0x1b, 0xfb, 0x81, 0x7b, 0xe2, 0x30, 0xac, 0xf0, 0x24, 0xa8, 0x8a, 0x68, 0xd5, 0xd3, 0x4b, 0x2c, 0x9d, 0x1f, 0xe1, 0xd2, 0x01, 0xe1, 0x71, 0xdc, 0x66,
0xbf, 0x04, 0xb2, 0x0b, 0xa8, 0x01, 0x57, 0x05, 0x7a, 0x8a, 0xad, 0xac, 0x32, 0xad, 0x46, 0x7b, 0x26, 0xfe, 0xfb, 0x4c, 0xfe, 0x59, 0x01, 0xbb, 0xdc, 0xbb, 0xc4, 0x6c, 0xed, 0x28, 0xf2, 0x4f,
0xb0, 0x95, 0x71, 0x8f, 0xef, 0x8f, 0xd5, 0x9d, 0xeb, 0x4a, 0x79, 0x0a, 0x9c, 0x76, 0xbe, 0x13, 0x3c, 0x4e, 0xb4, 0x3c, 0xa9, 0x6f, 0x87, 0xe2, 0x06, 0x6e, 0xc1, 0x79, 0x89, 0x9e, 0x26, 0xab,
0xfa, 0x12, 0xae, 0xa5, 0x12, 0x88, 0x58, 0x4b, 0x33, 0x63, 0xe5, 0xb9, 0xa4, 0x58, 0x2f, 0x2d, 0xa2, 0xcc, 0xb3, 0xf1, 0x10, 0x36, 0x0a, 0xea, 0xe9, 0x8b, 0xb3, 0xb9, 0x7b, 0x51, 0x0b, 0x4f,
0xde, 0x70, 0x5b, 0x5d, 0xcc, 0x44, 0xc0, 0xcb, 0xa6, 0xef, 0xf7, 0x02, 0x5c, 0xcf, 0xcb, 0x4d, 0x83, 0xd3, 0x2d, 0x57, 0xc2, 0x2f, 0xe1, 0x42, 0xce, 0x81, 0xb4, 0xb5, 0x30, 0xd5, 0x56, 0x99,
0x09, 0x7f, 0xe9, 0xf7, 0xbc, 0x61, 0x80, 0x1d, 0x2a, 0xa7, 0x20, 0xe1, 0x2e, 0xa3, 0xe7, 0x2f, 0x4a, 0x2e, 0xeb, 0xb5, 0xf9, 0x0b, 0x6e, 0xe3, 0x80, 0x70, 0x69, 0xf0, 0x7d, 0xa7, 0xef, 0x8f,
0xf3, 0x97, 0x3e, 0x73, 0x8e, 0x62, 0x43, 0x49, 0x9c, 0xae, 0x44, 0x4f, 0x61, 0x33, 0xed, 0xb9, 0x0a, 0x5c, 0x2c, 0xf3, 0xcd, 0xa8, 0xb8, 0xf4, 0xbb, 0xc1, 0x20, 0x22, 0x1e, 0x53, 0x5d, 0x90,
0x00, 0x6b, 0xb9, 0x3e, 0xa8, 0x03, 0x1b, 0x5a, 0xf0, 0x05, 0x28, 0xcb, 0x3a, 0x5c, 0x94, 0xb0, 0xe5, 0xae, 0xc0, 0x17, 0x97, 0xf9, 0xe3, 0x90, 0x7b, 0xcf, 0x53, 0x41, 0x95, 0x38, 0x93, 0x89,
0x53, 0xd8, 0x0c, 0x6f, 0xe9, 0x97, 0xcd, 0xd7, 0x2f, 0x45, 0xd1, 0x2b, 0xe9, 0xd4, 0x94, 0xf0, 0xf7, 0x61, 0x3d, 0xaf, 0x39, 0x47, 0xd6, 0x4a, 0x75, 0xb0, 0x03, 0x6b, 0x86, 0xf1, 0x39, 0x52,
0xe9, 0x89, 0x80, 0xe2, 0xab, 0x09, 0x5b, 0x69, 0x35, 0x27, 0x2b, 0x79, 0xcf, 0x28, 0x64, 0x69, 0x56, 0x54, 0x38, 0x6b, 0xc2, 0x5e, 0xc1, 0x7a, 0xfc, 0xae, 0x7f, 0xdf, 0xf9, 0xfa, 0xa5, 0x2a,
0x4a, 0x64, 0xc1, 0x15, 0x81, 0x57, 0x64, 0x24, 0x8f, 0x57, 0x4d, 0xc7, 0x27, 0x27, 0x15, 0x7c, 0x6b, 0x25, 0xef, 0x9a, 0x51, 0xd1, 0x3d, 0x09, 0x50, 0x62, 0x37, 0xcb, 0x56, 0x9e, 0x2d, 0x92,
0x91, 0xc9, 0xc9, 0x71, 0xe1, 0x74, 0x6a, 0xe9, 0x45, 0x9c, 0xd2, 0x6c, 0x3a, 0x33, 0x0e, 0xe8, 0x95, 0xdd, 0x33, 0x5a, 0xb2, 0x0c, 0xa6, 0x78, 0x17, 0x4a, 0xbc, 0x12, 0x21, 0x35, 0x5e, 0x0d,
0x11, 0xac, 0xab, 0xfb, 0x13, 0x41, 0x96, 0x67, 0x06, 0xc9, 0xd8, 0xa7, 0x5a, 0xa2, 0xbc, 0x60, 0x9e, 0xe8, 0x9c, 0x9c, 0xf1, 0x79, 0x3a, 0xa7, 0x44, 0x45, 0xa4, 0xd3, 0x70, 0x2f, 0xed, 0xd4,
0x4b, 0xec, 0xfc, 0x59, 0x86, 0x15, 0x61, 0xd4, 0xee, 0xbf, 0x40, 0xbb, 0x00, 0xc9, 0x0f, 0x06, 0xa6, 0xa7, 0xb3, 0xa0, 0x80, 0x77, 0x60, 0x55, 0x3f, 0x9f, 0x34, 0xb2, 0x38, 0xd5, 0x48, 0x41,
0xa4, 0xd2, 0xaf, 0xfd, 0xdc, 0xa8, 0xdd, 0x3c, 0x63, 0x85, 0x12, 0xf4, 0x13, 0xdc, 0x99, 0xfd, 0x3e, 0x57, 0x12, 0xf5, 0x39, 0x4b, 0x62, 0xf7, 0xaf, 0x3a, 0x2c, 0x49, 0xa1, 0xfd, 0xde, 0x23,
0x75, 0x8f, 0xee, 0x6b, 0xce, 0x73, 0xfe, 0x37, 0xd4, 0x3e, 0x39, 0x87, 0x35, 0x25, 0xe8, 0x9d, 0xdc, 0x03, 0xc8, 0x7e, 0x49, 0xa0, 0x9e, 0x7e, 0xe3, 0x77, 0x48, 0xeb, 0xf2, 0x29, 0x3b, 0x8c,
0x01, 0xdb, 0x73, 0xbf, 0xbb, 0x51, 0x4b, 0x09, 0xba, 0xc8, 0xdf, 0x82, 0xda, 0xa7, 0xe7, 0x73, 0xe2, 0x4f, 0x70, 0x6d, 0xfa, 0xff, 0x00, 0xbc, 0x69, 0x28, 0xcf, 0xf8, 0x43, 0xd1, 0xfa, 0xe4,
0x90, 0x38, 0xcc, 0xfe, 0x20, 0xd6, 0x70, 0x98, 0xfb, 0x25, 0xaf, 0xe1, 0xb0, 0xc0, 0x97, 0x76, 0x2d, 0xa4, 0x19, 0xc5, 0x37, 0x16, 0x6c, 0xce, 0xfc, 0x52, 0xc7, 0x1d, 0xcd, 0xe8, 0x3c, 0xff,
0x07, 0xaa, 0xca, 0x25, 0x1c, 0xdd, 0xd4, 0xbd, 0x95, 0x2f, 0xd8, 0x5a, 0xed, 0xac, 0x25, 0x4a, 0x17, 0x5a, 0x9f, 0xbe, 0x9d, 0x82, 0xc2, 0x61, 0xfa, 0x27, 0xb4, 0x81, 0xc3, 0xcc, 0x6f, 0x7f,
0xd0, 0x53, 0x58, 0xd5, 0x2e, 0x77, 0xe8, 0x96, 0x6e, 0xac, 0x5d, 0x66, 0x6b, 0xb7, 0xcf, 0x5e, 0x03, 0x87, 0x39, 0xbe, 0xcd, 0x3b, 0xd0, 0xd4, 0x1e, 0xe1, 0x78, 0xd9, 0xd4, 0xd6, 0xbe, 0x79,
0xa4, 0x04, 0xf5, 0xc5, 0xb7, 0xb3, 0x72, 0x3b, 0x41, 0xb9, 0xf6, 0xd1, 0x65, 0xae, 0xf6, 0xbf, 0x5b, 0xad, 0xd3, 0xb6, 0x18, 0xc5, 0xfb, 0xb0, 0x6c, 0x3c, 0xee, 0xf0, 0x8a, 0x29, 0x6c, 0x3c,
0x19, 0xab, 0x94, 0xa0, 0x81, 0x38, 0xca, 0x32, 0xaf, 0x6f, 0x64, 0xe9, 0x6e, 0x79, 0xb7, 0x8b, 0x66, 0x5b, 0x57, 0x4f, 0xdf, 0x64, 0x14, 0x7b, 0xf2, 0x6b, 0x5b, 0x7b, 0x9d, 0x60, 0xa9, 0x7c,
0xda, 0x07, 0x73, 0x6d, 0x28, 0x41, 0x5f, 0x8b, 0xdb, 0x54, 0xea, 0x05, 0x83, 0xea, 0xba, 0x6b, 0xf2, 0x98, 0x6b, 0xfd, 0x6f, 0xca, 0x2e, 0xa3, 0xd8, 0x97, 0xa3, 0xac, 0x70, 0x7d, 0xa3, 0x63,
0xf6, 0xdd, 0x57, 0xdb, 0x9e, 0x63, 0x41, 0x09, 0xfa, 0x4a, 0x5c, 0x5e, 0xf5, 0xb3, 0x10, 0xfd, 0xaa, 0x95, 0xbd, 0x2e, 0x5a, 0x1f, 0xcc, 0x94, 0x61, 0x14, 0xbf, 0x96, 0xaf, 0xa9, 0xdc, 0x05,
0x3f, 0x4b, 0xb0, 0x1e, 0xb8, 0x3e, 0xdb, 0x80, 0x92, 0x47, 0x37, 0xbe, 0xd9, 0x6a, 0x26, 0xff, 0x83, 0x6d, 0x53, 0xb5, 0x78, 0xf7, 0xb5, 0x36, 0x67, 0x48, 0x30, 0x8a, 0x5f, 0xc9, 0xc7, 0xab,
0x41, 0x3f, 0x8f, 0x9f, 0xbe, 0x5f, 0x16, 0x3f, 0x39, 0x1f, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x39, 0x0b, 0xf1, 0xff, 0xc5, 0x04, 0x9b, 0x86, 0xdb, 0xd3, 0x05, 0x18, 0xbd, 0x73, 0xe9, 0x9b,
0xcd, 0xf8, 0xf8, 0x38, 0x2f, 0x15, 0x00, 0x00, 0x8d, 0xed, 0xec, 0xcf, 0xe9, 0xe7, 0xe9, 0xea, 0xfb, 0x45, 0xf9, 0x5b, 0xf4, 0xd6, 0xbf, 0x01,
0x00, 0x00, 0xff, 0xff, 0x9c, 0x40, 0xb4, 0xf6, 0x61, 0x15, 0x00, 0x00,
} }

@ -65,21 +65,23 @@ message GetChatLogsReq {
message ChatLog { message ChatLog {
string ServerMsgID = 1; string ServerMsgID = 1;
string stringClientMsgID = 2; string ClientMsgID = 2;
string SendID = 3; string SendID = 3;
string RecvID = 4; string RecvID = 4;
int32 SenderPlatformID = 5; string groupID = 5;
string SenderNickname = 6; string recvNickname = 6;
string SenderFaceURL = 7; int32 SenderPlatformID = 7;
string GroupName = 8; string SenderNickname = 8;
int32 SessionType = 9; string SenderFaceURL = 9;
int32 MsgFrom = 10; string GroupName = 10;
int32 ContentType = 11; int32 SessionType = 11;
string Content = 12; int32 MsgFrom = 12;
int32 Status = 13; int32 ContentType = 13;
int64 SendTime = 14; string Content = 14;
int64 CreateTime = 15; int32 Status = 15;
string Ex = 16; int64 SendTime = 16;
int64 CreateTime = 17;
string Ex = 18;
} }
message GetChatLogsResp { message GetChatLogsResp {

File diff suppressed because it is too large Load Diff

@ -219,27 +219,19 @@ message CMSGroup {
string GroupOwnerUserID = 3; string GroupOwnerUserID = 3;
} }
message GetGroupReq {
string GroupName = 1;
server_api_params.RequestPagination Pagination = 2;
string OperationID = 3;
}
message GetGroupResp {
repeated CMSGroup CMSGroups = 1;
server_api_params.RequestPagination Pagination = 2;
int32 GroupNums = 3;
}
message GetGroupsReq { message GetGroupsReq {
server_api_params.RequestPagination Pagination = 1; server_api_params.RequestPagination Pagination = 1;
string OperationID = 2; string GroupName = 2;
string GroupID = 3;
string OperationID = 4;
} }
message GetGroupsResp { message GetGroupsResp {
repeated CMSGroup CMSGroups = 1; repeated CMSGroup CMSGroups = 1;
server_api_params.RequestPagination Pagination = 2; server_api_params.ResponsePagination Pagination = 2;
int32 GroupNum = 3; int32 GroupNum = 3;
CommonResp commonResp = 4;
} }
message GetGroupMemberReq { message GetGroupMemberReq {
@ -247,26 +239,6 @@ message GetGroupMemberReq {
string OperationID = 2; string OperationID = 2;
} }
message OperateUserRoleReq {
string GroupID = 1;
string UserID = 2;
int32 RoleLevel = 3;
string OperationID = 4;
}
message OperateUserRoleResp {
}
message GetGroupByIDReq {
string GroupID = 1;
string OperationID = 2;
}
message GetGroupByIDResp {
CMSGroup CMSGroup = 1;
}
message GetGroupMembersCMSReq { message GetGroupMembersCMSReq {
string GroupID = 1; string GroupID = 1;
string UserName = 2; string UserName = 2;
@ -278,30 +250,7 @@ message GetGroupMembersCMSResp {
repeated server_api_params.GroupMemberFullInfo members = 1; repeated server_api_params.GroupMemberFullInfo members = 1;
server_api_params.ResponsePagination Pagination = 2; server_api_params.ResponsePagination Pagination = 2;
int32 MemberNums = 3; int32 MemberNums = 3;
} CommonResp commonResp = 4;
message RemoveGroupMembersCMSReq {
string GroupID = 1;
repeated string UserIDList = 2;
string OperationID = 3;
string OpUserID = 4;
}
message RemoveGroupMembersCMSResp {
repeated string success = 1;
repeated string failed = 2;
}
message AddGroupMembersCMSReq {
string GroupID = 1;
repeated string UserIDList = 2;
string OperationID = 3;
string OpUserID = 4;
}
message AddGroupMembersCMSResp {
repeated string success = 1;
repeated string failed = 2;
} }
message DismissGroupReq{ message DismissGroupReq{
@ -444,13 +393,9 @@ service group{
rpc inviteUserToGroup(InviteUserToGroupReq) returns (InviteUserToGroupResp); rpc inviteUserToGroup(InviteUserToGroupReq) returns (InviteUserToGroupResp);
rpc getGroupAllMember(GetGroupAllMemberReq) returns(GetGroupAllMemberResp); rpc getGroupAllMember(GetGroupAllMemberReq) returns(GetGroupAllMemberResp);
rpc GetGroupByID(GetGroupByIDReq) returns(GetGroupByIDResp);
rpc GetGroup(GetGroupReq) returns(GetGroupResp);
rpc GetGroups(GetGroupsReq) returns(GetGroupsResp); rpc GetGroups(GetGroupsReq) returns(GetGroupsResp);
rpc OperateUserRole(OperateUserRoleReq) returns(OperateUserRoleResp);
rpc GetGroupMembersCMS(GetGroupMembersCMSReq) returns(GetGroupMembersCMSResp); rpc GetGroupMembersCMS(GetGroupMembersCMSReq) returns(GetGroupMembersCMSResp);
rpc RemoveGroupMembersCMS(RemoveGroupMembersCMSReq) returns(RemoveGroupMembersCMSResp);
rpc AddGroupMembersCMS(AddGroupMembersCMSReq) returns(AddGroupMembersCMSResp);
rpc DismissGroup(DismissGroupReq) returns(DismissGroupResp); rpc DismissGroup(DismissGroupReq) returns(DismissGroupResp);
rpc MuteGroupMember(MuteGroupMemberReq) returns(MuteGroupMemberResp); rpc MuteGroupMember(MuteGroupMemberReq) returns(MuteGroupMemberResp);
@ -459,7 +404,6 @@ service group{
rpc CancelMuteGroup(CancelMuteGroupReq) returns(CancelMuteGroupResp); rpc CancelMuteGroup(CancelMuteGroupReq) returns(CancelMuteGroupResp);
rpc SetGroupMemberNickname(SetGroupMemberNicknameReq) returns (SetGroupMemberNicknameResp); rpc SetGroupMemberNickname(SetGroupMemberNicknameReq) returns (SetGroupMemberNicknameResp);
rpc GetJoinedSuperGroupList(GetJoinedSuperGroupListReq) returns (GetJoinedSuperGroupListResp); rpc GetJoinedSuperGroupList(GetJoinedSuperGroupListReq) returns (GetJoinedSuperGroupListResp);
rpc GetSuperGroupsInfo(GetSuperGroupsInfoReq) returns (GetSuperGroupsInfoResp); rpc GetSuperGroupsInfo(GetSuperGroupsInfoReq) returns (GetSuperGroupsInfoResp);
rpc SetGroupMemberInfo(SetGroupMemberInfoReq) returns (SetGroupMemberInfoResp); rpc SetGroupMemberInfo(SetGroupMemberInfoReq) returns (SetGroupMemberInfoResp);

Loading…
Cancel
Save