statistics

internal/cms_api/group/group.go

@@ -20,8 +20,8 @@ import (
 
 func GetGroupById(c *gin.Context) {
 	var (
-		req cms_api_struct.GetGroupByIdRequest
-		resp cms_api_struct.GetGroupByIdResponse
+		req   cms_api_struct.GetGroupByIdRequest
+		resp  cms_api_struct.GetGroupByIdResponse
 		reqPb pbGroup.GetGroupByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
@@ -33,7 +33,7 @@ func GetGroupById(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroupById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error())
+		log.NewError(utils.GetSelfFuncName(), "GetGroupById	 failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -43,7 +43,7 @@ func GetGroupById(c *gin.Context) {
 	resp.CreateTime = (utils.UnixSecondToTime(int64(respPb.GroupInfo.CreateTime))).String()
 	resp.ProfilePhoto = respPb.GroupInfo.FaceURL
 	resp.GroupMasterName = respPb.GroupInfo.OwnerUserID
-	openIMHttp.RespHttp200(c, constant.OK, nil)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
 func GetGroups(c *gin.Context) {
@@ -141,7 +141,7 @@ func CreateGroup(c *gin.Context) {
 	reqPb.GroupInfo.CreatorUserID = req.GroupMasterId
 	for _, v := range req.GroupMembers {
 		reqPb.InitMemberList = append(reqPb.InitMemberList, &pbGroup.GroupAddMemberInfo{
-			UserID:  v,
+			UserID:    v,
 			RoleLevel: 1,
 		})
 	}
@@ -249,7 +249,6 @@ func OpenPrivateChat(c *gin.Context) {
 	openIMHttp.RespHttp200(c, constant.OK, nil)
 }
 
-
 func GetGroupsMember(c *gin.Context) {
 	var (
 		req cms_api_struct.GetGroupMembersRequest

internal/cms_api/message/message.go

@@ -1,25 +1,21 @@
 package message
 
 import (
+	openIMHttp "Open_IM/pkg/common/http"
+
+	"Open_IM/pkg/common/constant"
+
 	"github.com/gin-gonic/gin"
 )
 
-func Broadcast(c *gin.Context) {
-
-}
-
-func SearchMessageByUser(c *gin.Context) {
-
-}
-
-func SearchMessageByGroup(c *gin.Context) {
-
+func BroadcastMessage(c *gin.Context) {
+	openIMHttp.RespHttp200(c, constant.OK, nil)
 }
 
 func MassSendMassage(c *gin.Context) {
-
+	openIMHttp.RespHttp200(c, constant.OK, nil)
 }
 
-func Withdraw(c *gin.Context) {
-
+func WithdrawMessage(c *gin.Context) {
+	openIMHttp.RespHttp200(c, constant.OK, nil)
 }

internal/cms_api/router.go

@@ -21,15 +21,14 @@ func NewGinRouter() *gin.Engine {
 	adminRouterGroup := router.Group("/admin")
 	{
 		adminRouterGroup.POST("/register", admin.AdminRegister)
-		adminRouterGroup.POST("/login", admin.AdminLogin)
 		adminRouterGroup.GET("/get_user_settings", admin.GetAdminSettings)
 		adminRouterGroup.POST("/alter_user_settings", admin.AlterAdminSettings)
 	}
 	statisticsRouterGroup := router.Group("/statistics")
 	{
 		statisticsRouterGroup.GET("/get_messages_statistics", statistics.GetMessagesStatistics)
-		statisticsRouterGroup.GET("/get_users_statistics", statistics.GetUsersStatistics)
-		statisticsRouterGroup.GET("/get_groups_statistics", statistics.GetGroupsStatistics)
+		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)
 	}
@@ -49,11 +48,9 @@ func NewGinRouter() *gin.Engine {
 	}
 	messageRouterGroup := router.Group("/message")
 	{
-		messageRouterGroup.POST("/broadcast", message.Broadcast)
-		messageRouterGroup.GET("/search_message_by_user", message.SearchMessageByUser)
-		messageRouterGroup.POST("/message_mass_send", message.MassSendMassage)
-		messageRouterGroup.GET("/search_message_by_group", message.SearchMessageByGroup)
-		messageRouterGroup.POST("/withdraw_message", message.Withdraw)
+		messageRouterGroup.POST("/broadcast_message", message.BroadcastMessage)
+		messageRouterGroup.POST("/mass_send_message", message.MassSendMassage)
+		messageRouterGroup.POST("/withdraw_message", message.WithdrawMessage)
 	}
 	groupRouterGroup := router.Group("/group")
 	{
@@ -75,14 +72,15 @@ func NewGinRouter() *gin.Engine {
 	userRouterGroup := router.Group("/user")
 	{
 		userRouterGroup.POST("/resign", user.ResignUser)
-		userRouterGroup.GET("/get_user", user.GetUser)
+		userRouterGroup.GET("/get_user_by_id", user.GetUserById)
 		userRouterGroup.POST("/alter_user", user.AlterUser)
 		userRouterGroup.GET("/get_users", user.GetUsers)
 		userRouterGroup.POST("/add_user", user.AddUser)
 		userRouterGroup.POST("/unblock_user", user.UnblockUser)
 		userRouterGroup.POST("/block_user", user.BlockUser)
 		userRouterGroup.GET("/get_block_users", user.GetBlockUsers)
-		userRouterGroup.GET("/get_block_user", user.GetBlockUser)
+		userRouterGroup.GET("/get_block_user_by_id", user.GetBlockUserById)
+		userRouterGroup.POST("/delete_user", user.DeleteUser)
 	}
 	return baseRouter
 }

internal/cms_api/statistics/statistics.go

@@ -2,30 +2,221 @@ package statistics
 
 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"
+	pb "Open_IM/pkg/proto/statistics"
+	"Open_IM/pkg/utils"
+	"context"
+	"strings"
+
 	"github.com/gin-gonic/gin"
-	statisticsPb "Open_IM/pkg/proto/statistics"
 )
 
 func GetMessagesStatistics(c *gin.Context) {
 	var (
-		req cms_api_struct.GetGroupMembersRequest
-		resp cms_api_struct.GetGroupMembersResponse
-		reqPb statisticsPb.GetMessageStatisticsReq
+		req   cms_api_struct.GetMessageStatisticsRequest
+		resp  cms_api_struct.GetMessageStatisticsResponse
+		reqPb pb.GetMessageStatisticsReq
 	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetMessageStatistics(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, constant.ErrServer, resp)
+		log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.GroupMessageNum = int(respPb.GroupMessageNum)
+	resp.PrivateMessageNum = int(respPb.PrivateMessageNum)
+	for _, v := range respPb.PrivateMessageNumList {
+		resp.PrivateMessageNumList = append(resp.PrivateMessageNumList, struct {
+			Date       string "json:\"date\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			Date:       v.Date,
+			MessageNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.GroupMessageNumList {
+		resp.GroupMessageNumList = append(resp.GroupMessageNumList, struct {
+			Date       string "json:\"date\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			Date:       v.Date,
+			MessageNum: int(v.Num),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
-func GetUsersStatistics(c *gin.Context) {
-
+func GetUserStatistics(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetUserStatisticsRequest
+		resp  cms_api_struct.GetUserStatisticsResponse
+		reqPb pb.GetUserStatisticsReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUserStatistics(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", utils.GetSelfFuncName(), err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.ActiveUserNum = int(respPb.ActiveUserNum)
+	resp.IncreaseUserNum = int(respPb.IncreaseUserNum)
+	resp.TotalUserNum = int(respPb.TotalUserNum)
+	for _, v := range respPb.ActiveUserNumList {
+		resp.ActiveUserNumList = append(resp.ActiveUserNumList, struct {
+			Date          string "json:\"date\""
+			ActiveUserNum int    "json:\"active_user_num\""
+		}{
+			Date:          v.Date,
+			ActiveUserNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.IncreaseUserNumList {
+		resp.IncreaseUserNumList = append(resp.IncreaseUserNumList, struct {
+			Date            string "json:\"date\""
+			IncreaseUserNum int    "json:\"increase_user_num\""
+		}{
+			Date:            v.Date,
+			IncreaseUserNum: int(v.Num),
+		})
+	}
+	for _, v := range respPb.TotalUserNumList {
+		resp.TotalUserNumList = append(resp.TotalUserNumList, struct {
+			Date         string "json:\"date\""
+			TotalUserNum int    "json:\"total_user_num\""
+		}{
+			Date:         v.Date,
+			TotalUserNum: int(v.Num),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
-func GetGroupsStatistics(c *gin.Context) {
+func GetGroupStatistics(c *gin.Context) {
+	var (
+		req   cms_api_struct.GetGroupStatisticsRequest
+		resp  cms_api_struct.GetGroupStatisticsResponse
+		reqPb pb.GetGroupStatisticsReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, &req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetGroupStatistics(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	// utils.CopyStructFields(&resp, respPb)
+	resp.IncreaseGroupNum = int(respPb.GetIncreaseGroupNum())
+	resp.TotalGroupNum = int(respPb.GetTotalGroupNum())
+	for _, v := range respPb.IncreaseGroupNumList {
+		resp.IncreaseGroupNumList = append(resp.IncreaseGroupNumList,
+			struct {
+				Date             string "json:\"date\""
+				IncreaseGroupNum int    "json:\"increase_group_num\""
+			}{
+				Date:             v.Date,
+				IncreaseGroupNum: int(v.Num),
+			})
+	}
+	for _, v := range respPb.TotalGroupNumList {
+		resp.TotalGroupNumList = append(resp.TotalGroupNumList,
+			struct {
+				Date          string "json:\"date\""
+				TotalGroupNum int    "json:\"total_group_num\""
+			}{
+				Date:          v.Date,
+				TotalGroupNum: int(v.Num),
+			})
 
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
 func GetActiveUser(c *gin.Context) {
-
+	var (
+		req   cms_api_struct.GetActiveUserRequest
+		resp  cms_api_struct.GetActiveUserResponse
+		reqPb pb.GetActiveUserReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetActiveUser(context.Background(), &reqPb)
+	if err != nil {
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	utils.CopyStructFields(&resp.ActiveUserList, respPb.Users)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
 func GetActiveGroup(c *gin.Context) {
-
+	var (
+		req   cms_api_struct.GetActiveGroupRequest
+		resp  cms_api_struct.GetActiveGroupResponse
+		reqPb pb.GetActiveGroupReq
+	)
+	reqPb.StatisticsReq = &pb.StatisticsReq{}
+	if err := c.ShouldBindQuery(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	utils.CopyStructFields(&reqPb.StatisticsReq, req)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetActiveGroup(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	for _, group := range respPb.Groups {
+		resp.ActiveGroupList = append(resp.ActiveGroupList, struct {
+			GroupName  string "json:\"group_name\""
+			GroupId    string "json:\"group_id\""
+			MessageNum int    "json:\"message_num\""
+		}{
+			GroupName:  group.GroupName,
+			GroupId:    group.GroupId,
+			MessageNum: int(group.MessageNum),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

internal/cms_api/user/user.go

@@ -18,23 +18,23 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func GetUser(c *gin.Context) {
+func GetUserById(c *gin.Context) {
 	var (
 		req   cms_api_struct.GetUserRequest
 		resp  cms_api_struct.GetUserResponse
-		reqPb pb.GetUserReq
+		reqPb pb.GetUserByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		log.NewError("GetUser", utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
 	utils.CopyStructFields(&reqPb, &req)
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
 	client := pb.NewUserClient(etcdConn)
-	respPb, err := client.GetUser(context.Background(), &reqPb)
+	respPb, err := client.GetUserById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError("GetUserFailed", utils.GetSelfFuncName(), err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -67,7 +67,6 @@ func GetUsers(c *gin.Context) {
 		return
 	}
 	utils.CopyStructFields(&resp.Users, respPb.User)
-	resp.UserNum = int(respPb.UserNum)
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
@@ -101,7 +100,6 @@ func AlterUser(c *gin.Context) {
 		req   cms_api_struct.AlterUserRequest
 		resp  cms_api_struct.AlterUserResponse
 		reqPb pb.AlterUserReq
-		_     *pb.AlterUserResp
 	)
 	if err := c.BindJSON(&req); err != nil {
 		log.NewError("0", "BindJSON failed ", err.Error())
@@ -222,28 +220,29 @@ func GetBlockUsers(c *gin.Context) {
 			EndDisableTime:   v.EndDisableTime,
 		})
 	}
-	resp.BlockUserNum = int(respPb.BlockUserNum)
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
-func GetBlockUser(c *gin.Context) {
+func GetBlockUserById(c *gin.Context) {
 	var (
 		req   cms_api_struct.GetBlockUserRequest
 		resp  cms_api_struct.GetBlockUserResponse
-		reqPb pb.GetBlockUserReq
+		reqPb pb.GetBlockUserByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
 		log.NewError("0", "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
+	reqPb.UserId = req.UserId
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
 	client := pb.NewUserClient(etcdConn)
-	respPb, err := client.GetBlockUser(context.Background(), &reqPb)
+	respPb, err := client.GetBlockUserById(context.Background(), &reqPb)
 	if err != nil {
-		openIMHttp.RespHttp200(c, constant.ErrServer, resp)
+		log.NewError("0", "GetBlockUserById rpc failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
 	resp.EndDisableTime = respPb.BlockUser.EndDisableTime
@@ -251,3 +250,25 @@ func GetBlockUser(c *gin.Context) {
 	utils.CopyStructFields(&resp, respPb.BlockUser.User)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
+
+func DeleteUser(c *gin.Context) {
+	var (
+		req   cms_api_struct.DeleteUserRequest
+		reqPb pb.DeleteUserReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.UserId = req.UserId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	_, err := client.DeleteUser(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError("0", "DeleteUser rpc failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}

internal/rpc/group/group.go

@@ -648,16 +648,15 @@ func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdR
 		return resp, err
 	}
 	resp.GroupInfo = &open_im_sdk.GroupInfo{
-		GroupID:        group.GroupID,
-		GroupName:      group.GroupName,
-		FaceURL:        group.FaceUrl,
-		OwnerUserID:    group.CreatorUserID,
+		GroupID:       group.GroupID,
+		GroupName:     group.GroupName,
+		FaceURL:       group.FaceUrl,
+		OwnerUserID:   group.CreatorUserID,
 		MemberCount:   0,
 		Status:        group.Status,
 		CreatorUserID: group.CreatorUserID,
-		GroupType: group.GroupType,
+		GroupType:     group.GroupType,
 	}
-
 	resp.GroupInfo.CreatorUserID = group.CreatorUserID
 	return resp, nil
 }
@@ -721,7 +720,7 @@ func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*
 }
 
 func (s *groupServer) OperateGroupStatus(_ context.Context, req *pbGroup.OperateGroupStatusReq) (*pbGroup.OperateGroupStatusResp, error) {
-	log.NewInfo(req.OperationID,  utils.GetSelfFuncName(), req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
 	resp := &pbGroup.OperateGroupStatusResp{}
 	if err := imdb.OperateGroupStatus(req.GroupId, req.Status); err != nil {
 		return resp, err

internal/rpc/statistics/statistics.go

@@ -2,13 +2,19 @@ package statistics
 
 import (
 	"Open_IM/pkg/common/config"
+	"context"
+	"fmt"
+	"time"
+
 	//"Open_IM/pkg/common/constant"
 	//"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/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"
@@ -26,18 +32,18 @@ type statisticsServer struct {
 	etcdAddr        []string
 }
 
-func NewStatisticsGroupServer(port int) *statisticsServer {
-	log.NewPrivateLog("group")
+func NewStatisticsServer(port int) *statisticsServer {
+	log.NewPrivateLog("Statistics")
 	return &statisticsServer{
 		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImStatisticsName,
 		etcdSchema:      config.Config.Etcd.EtcdSchema,
 		etcdAddr:        config.Config.Etcd.EtcdAddr,
 	}
 }
 
 func (s *statisticsServer) Run() {
-	log.NewInfo("0", "group rpc start ")
+	log.NewInfo("0", "Statistics rpc start ")
 	ip := utils.ServerIP
 	registerAddress := ip + ":" + strconv.Itoa(s.rpcPort)
 	//listener network
@@ -63,5 +69,270 @@ func (s *statisticsServer) Run() {
 		log.NewError("0", "Serve failed ", err.Error())
 		return
 	}
-	log.NewInfo("0", "group rpc success")
-}
+	log.NewInfo("0", "statistics rpc success")
+}
+
+func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.GetActiveGroupReq) (*pbStatistics.GetActiveGroupResp, error) {
+	log.NewInfo("GetActiveGroup", utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetActiveGroupResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError("GetActiveGroup", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12)
+	if err != nil {
+		log.NewError("GetActiveGroup", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	for _, activeGroup := range activeGroups {
+		resp.Groups = append(resp.Groups,
+			&pbStatistics.GroupResp{
+				GroupName:  activeGroup.Name,
+				GroupId:    activeGroup.Id,
+				MessageNum: int32(activeGroup.MessageNum),
+			})
+	}
+	return resp, nil
+}
+
+func (s *statisticsServer) GetActiveUser(_ context.Context, req *pbStatistics.GetActiveUserReq) (*pbStatistics.GetActiveUserResp, error) {
+	log.NewInfo("GetActiveUser", utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetActiveUserResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError("GetActiveUser", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	activeUsers, err := imdb.GetActiveUsers(fromTime, toTime, 12)
+	if err != nil {
+		log.NewError("GetActiveUser", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	for _, activeUser := range activeUsers {
+		resp.Users = append(resp.Users,
+			&pbStatistics.UserResp{
+				UserId:     activeUser.Id,
+				NickName:   activeUser.Name,
+				MessageNum: int32(activeUser.MessageNum),
+			},
+		)
+	}
+	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()
+}
+
+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):
+		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("GetGroupStatistics", utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetGroupStatisticsResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	increaseGroupNum, err := imdb.GetIncreaseGroupNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	totalGroupNum, err := imdb.GetTotalGroupNum()
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	resp.IncreaseGroupNum = increaseGroupNum
+	resp.TotalGroupNum = totalGroupNum
+	times := GetRangeDate(fromTime, toTime)
+	log.NewInfo("", "times:", times)
+	for _, v := range times {
+		num, err := imdb.GetIncreaseGroupNum(v[0], v[1])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+		}
+		resp.IncreaseGroupNumList = append(resp.IncreaseGroupNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+		num, err = imdb.GetGroupNum(v[0])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+		}
+		resp.TotalGroupNumList = append(resp.TotalGroupNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+	}
+	return resp, nil
+}
+
+func (s *statisticsServer) GetMessageStatistics(_ context.Context, req *pbStatistics.GetMessageStatisticsReq) (*pbStatistics.GetMessageStatisticsResp, error) {
+	log.NewInfo("GetMessageStatistics", utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetMessageStatisticsResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	privateMessageNum, err := imdb.GetPrivateMessageNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	groupMessageNum, err := imdb.GetGroupMessageNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+	}
+	resp.PrivateMessageNum = privateMessageNum
+	resp.GroupMessageNum = groupMessageNum
+	times := GetRangeDate(fromTime, toTime)
+	fmt.Println(times)
+	for _, v := range times {
+		num, err := imdb.GetPrivateMessageNum(v[0], v[1])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+		}
+		resp.PrivateMessageNumList = append(resp.PrivateMessageNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+
+		num, err = imdb.GetGroupMessageNum(v[0], v[1])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+		}
+		resp.GroupMessageNumList = append(resp.GroupMessageNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+	}
+	fmt.Println(resp)
+	return resp, nil
+}
+
+func (s *statisticsServer) GetUserStatistics(_ context.Context, req *pbStatistics.GetUserStatisticsReq) (*pbStatistics.GetUserStatisticsResp, error) {
+	log.NewInfo("GetUserStatistics", utils.GetSelfFuncName(), req.String())
+	resp := &pbStatistics.GetUserStatisticsResp{}
+	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
+	if err != nil {
+		return resp, err
+	}
+	activeUserNum, err := imdb.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError("GetUserStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	increaseUserNum, err := imdb.GetIncreaseUserNum(fromTime, toTime.Add(time.Hour*24))
+	if err != nil {
+		log.NewError("GetUserStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	totalUserNum, err := imdb.GetTotalUserNum()
+	if err != nil {
+		log.NewError("GetUserStatistics", utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	resp.ActiveUserNum = activeUserNum
+	resp.TotalUserNum = totalUserNum
+	resp.IncreaseUserNum = increaseUserNum
+
+	times := GetRangeDate(fromTime, toTime)
+	for _, v := range times {
+		num, err := imdb.GetActiveUserNum(v[0], v[1])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error())
+		}
+		resp.ActiveUserNumList = append(resp.ActiveUserNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+		num, err = imdb.GetTotalUserNumByDate(v[0])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetTotalUserNumByDate", v, err.Error())
+		}
+		resp.TotalUserNumList = append(resp.TotalUserNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+		num, err = imdb.GetIncreaseUserNum(v[0], v[1])
+		if err != nil {
+			log.NewError("", utils.GetSelfFuncName(), "GetIncreaseUserNum", v, err.Error())
+		}
+		resp.IncreaseUserNumList = append(resp.IncreaseUserNumList, &pbStatistics.DateNumList{
+			Date: v[0].String(),
+			Num:  num,
+		})
+	}
+	return resp, nil
+}

internal/rpc/user/user.go

@@ -243,9 +243,9 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
 }
 
-func (s *userServer) GetUser(ctx context.Context, req *pbUser.GetUserReq) (*pbUser.GetUserResp, error) {
+func (s *userServer) GetUserById(ctx context.Context, req *pbUser.GetUserByIdReq) (*pbUser.GetUserByIdResp, error) {
 	log.NewInfo(req.OperationID, "GetUser args ", req.String())
-	resp := &pbUser.GetUserResp{User: &pbUser.User{}}
+	resp := &pbUser.GetUserByIdResp{User: &pbUser.User{}}
 	user, err := imdb.GetUserByUserID(req.UserId)
 	if err != nil {
 		return resp, nil
@@ -259,7 +259,7 @@ func (s *userServer) GetUser(ctx context.Context, req *pbUser.GetUserReq) (*pbUs
 		Nickname:     user.Nickname,
 		UserId:       user.UserID,
 		CreateTime:   user.CreateTime.String(),
-		IsBlock: isBlock,
+		IsBlock:      isBlock,
 	}
 	return resp, nil
 }
@@ -271,11 +271,6 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 	if err != nil {
 		return resp, nil
 	}
-	usersNum, err := imdb.GetUsersNumCount()
-	if err != nil {
-		return resp, nil
-	}
-	resp.UserNum = int32(usersNum)
 	for _, v := range users {
 		isBlock, err := imdb.UserIsBlock(v.UserID)
 		if err == nil {
@@ -356,11 +351,9 @@ func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUser
 	if err != nil {
 		return resp, constant.ErrDB
 	}
-	usersNum, err := imdb.GetBlockUsersNumCount()
 	if err != nil {
 		return resp, constant.ErrDB
 	}
-	resp.BlockUserNum = int32(usersNum)
 	for _, v := range blockUsers {
 		resp.BlockUsers = append(resp.BlockUsers, &pbUser.BlockUser{
 			User: &pbUser.User{
@@ -380,16 +373,33 @@ func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUser
 	return resp, nil
 }
 
-func (s *userServer) GetBlockUser(_ context.Context, req *pbUser.GetBlockUserReq) (*pbUser.GetBlockUserResp, error) {
+func (s *userServer) GetBlockUserById(_ context.Context, req *pbUser.GetBlockUserByIdReq) (*pbUser.GetBlockUserByIdResp, error) {
 	log.NewInfo(req.OperationID, "GetBlockUser args ", req.String())
-	resp := &pbUser.GetBlockUserResp{}
+	resp := &pbUser.GetBlockUserByIdResp{}
 	user, err := imdb.GetBlockUserById(req.UserId)
 	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err)
 		return resp, err
 	}
-	resp.BlockUser = &pbUser.BlockUser{}
-	resp.BlockUser.BeginDisableTime = (user.BeginDisableTime).String()
-	resp.BlockUser.EndDisableTime = (user.EndDisableTime).String()
+	resp.BlockUser = &pbUser.BlockUser{
+		User: &pbUser.User{
+			ProfilePhoto: user.User.FaceURL,
+			Nickname:     user.User.Nickname,
+			UserId:       user.User.UserID,
+			IsBlock:      true,
+		},
+		BeginDisableTime: (user.BeginDisableTime).String(),
+		EndDisableTime:   (user.EndDisableTime).String(),
+	}
+	return resp, nil
+}
+
+func (s *userServer) DeleteUser(_ context.Context, req *pbUser.DeleteUserReq) (*pbUser.DeleteUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
+	resp := &pbUser.DeleteUserResp{}
+	if row := imdb.DeleteUser(req.UserId); row == 0 {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "delete error", row)
+		return resp, constant.ErrDB
+	}
 	return resp, nil
-
 }