cms

internal/api/group/group.go

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

internal/api/user/user.go

@@ -463,7 +463,7 @@ func GetUsers(c *gin.Context) {
 		resp  api.GetUsersResp
 		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)
 		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return

internal/cms_api/group/group.go

@@ -3,8 +3,6 @@ package group
 import (
 	"Open_IM/pkg/cms_api_struct"
 	"Open_IM/pkg/common/config"
-	"Open_IM/pkg/common/constant"
-	openIMHttp "Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	commonPb "Open_IM/pkg/proto/sdk_ws"
@@ -18,51 +16,15 @@ import (
 	"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) {
 	var (
 		req   cms_api_struct.GetGroupsRequest
 		resp  cms_api_struct.GetGroupsResponse
 		reqPb pbGroup.GetGroupsReq
 	)
-	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
-		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return
 	}
 	reqPb.OperationID = utils.OperationIDGenerator()
@@ -80,7 +42,7 @@ func GetGroups(c *gin.Context) {
 	respPb, err := client.GetGroups(context.Background(), &reqPb)
 	if err != nil {
 		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
 	}
 	for _, v := range respPb.CMSGroups {
@@ -91,54 +53,10 @@ func GetGroups(c *gin.Context) {
 		resp.Groups = append(resp.Groups, groupResp)
 	}
 	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.GroupNums = int(respPb.GroupNums)
-	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) {
@@ -147,9 +65,9 @@ func GetGroupMembers(c *gin.Context) {
 		reqPb pbGroup.GetGroupMembersCMSReq
 		resp  cms_api_struct.GetGroupMembersResponse
 	)
-	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
-		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return
 	}
 	reqPb.OperationID = utils.OperationIDGenerator()
@@ -171,7 +89,7 @@ func GetGroupMembers(c *gin.Context) {
 	respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
 		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
 	}
 	resp.ResponsePagination = cms_api_struct.ResponsePagination{
@@ -185,5 +103,5 @@ func GetGroupMembers(c *gin.Context) {
 		resp.GroupMembers = append(resp.GroupMembers, memberResp)
 	}
 	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})
 }

internal/cms_api/message_cms/message.go

@@ -3,7 +3,6 @@ package messageCMS
 import (
 	"Open_IM/pkg/cms_api_struct"
 	"Open_IM/pkg/common/config"
-	openIMHttp "Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	pbAdminCMS "Open_IM/pkg/proto/admin_cms"
@@ -13,8 +12,6 @@ import (
 	"net/http"
 	"strings"
 
-	"Open_IM/pkg/common/constant"
-
 	"github.com/gin-gonic/gin"
 )
 
@@ -24,9 +21,9 @@ func GetChatLogs(c *gin.Context) {
 		resp  cms_api_struct.GetChatLogsResp
 		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())
-		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
 		return
 	}
 	reqPb.Pagination = &pbCommon.RequestPagination{
@@ -46,7 +43,7 @@ func GetChatLogs(c *gin.Context) {
 	respPb, err := client.GetChatLogs(context.Background(), &reqPb)
 	if err != nil {
 		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
 	}
 	for _, v := range respPb.ChatLogs {
@@ -58,5 +55,5 @@ func GetChatLogs(c *gin.Context) {
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	resp.ChatLogsNum = int(respPb.ChatLogsNum)
 	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})
 }

internal/cms_api/middleware/jwt_auth.go

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

internal/cms_api/router.go

@@ -28,25 +28,17 @@ func NewGinRouter() *gin.Engine {
 	r2.Use(middleware.JWTAuth())
 	statisticsRouterGroup := r2.Group("/statistics")
 	{
-		statisticsRouterGroup.GET("/get_messages_statistics", statistics.GetMessagesStatistics)
-		statisticsRouterGroup.GET("/get_user_statistics", statistics.GetUserStatistics)
-		statisticsRouterGroup.GET("/get_group_statistics", statistics.GetGroupStatistics)
-		statisticsRouterGroup.GET("/get_active_user", statistics.GetActiveUser)
-		statisticsRouterGroup.GET("/get_active_group", statistics.GetActiveGroup)
+		statisticsRouterGroup.POST("/get_messages_statistics", statistics.GetMessagesStatistics)
+		statisticsRouterGroup.POST("/get_user_statistics", statistics.GetUserStatistics)
+		statisticsRouterGroup.POST("/get_group_statistics", statistics.GetGroupStatistics)
+		statisticsRouterGroup.POST("/get_active_user", statistics.GetActiveUser)
+		statisticsRouterGroup.POST("/get_active_group", statistics.GetActiveGroup)
 	}
 	groupRouterGroup := r2.Group("/group")
 	{
-		groupRouterGroup.GET("/get_group_by_id", group.GetGroupByID)
-		groupRouterGroup.GET("/get_groups", group.GetGroups)
-		groupRouterGroup.GET("/get_group_by_name", group.GetGroupByName)
-		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)
+		groupRouterGroup.POST("/get_groups", group.GetGroups)
+		groupRouterGroup.POST("/get_group_members", group.GetGroupMembers)
+		groupRouterGroup.POST("/get_members_in_group", group.GetGroupMembers)
 	}
 	userRouterGroup := r2.Group("/user")
 	{

internal/cms_api/statistics/statistics.go

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

internal/cms_api/user/user.go

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

internal/rpc/admin_cms/admin_cms.go

@@ -140,7 +140,7 @@ func (s *adminCMSServer) ReduceUserRegisterAddFriendIDList(_ context.Context, re
 		}
 	}
 	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) {
@@ -223,7 +223,7 @@ func (s *adminCMSServer) GetChatLogs(_ context.Context, req *pbAdminCMS.GetChatL
 			}
 			pbChatLog.SenderNickname = recvUser.Nickname
 
-		case constant.GroupChatType:
+		case constant.GroupChatType, constant.SuperGroupChatType:
 			group, err := imdb.GetGroupInfoByGroupID(chatLog.RecvID)
 			if err != nil {
 				log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed")

internal/rpc/group/group.go

@@ -6,7 +6,7 @@ import (
 	"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/db/rocks_cache"
+	rocksCache "Open_IM/pkg/common/db/rocks_cache"
 	"Open_IM/pkg/common/http"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
@@ -19,12 +19,13 @@ import (
 	pbUser "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
 	"context"
-	"google.golang.org/grpc"
 	"math/big"
 	"net"
 	"strconv"
 	"strings"
 	"time"
+
+	"google.golang.org/grpc"
 )
 
 type groupServer struct {
@@ -315,7 +316,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 
 				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
 			} else {
 				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) {
 	log.NewInfo(req.OperationID, "GroupApplicationResponse args ", req.String())
-
 	groupRequest := db.GroupRequest{}
 	utils.CopyStructFields(&groupRequest, req)
 	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) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", req.String())
 	resp := &pbGroup.GetGroupsResp{
 		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)
+	if req.GroupID != "" {
+		groupInfoDB, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.GroupID)
+			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
+			resp.CommonResp.ErrMsg = err.Error()
+			return resp, nil
+		}
+		resp.GroupNum = 1
+		groupInfo := &open_im_sdk.GroupInfo{}
+		utils.CopyStructFields(groupInfo, groupInfoDB)
+		resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{GroupInfo: groupInfo})
+	} else {
+		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)
+		}
+		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.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
+	resp.Pagination.CurrentPage = req.Pagination.PageNumber
 	resp.Pagination.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 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)
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", resp.String())
-	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 {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		}
-	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups resp", resp.String())
 	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)
 	if err != nil {
 		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)
 	if err != nil {
 		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)
 	resp.MemberNums = int32(groupMembersCount)
@@ -1501,151 +1419,6 @@ func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGrou
 	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) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
 	resp := &pbGroup.GetUserReqApplicationListResp{}

internal/rpc/message_cms/message_cms.go

@@ -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
-}

internal/rpc/statistics/statistics.go

@@ -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
-}