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)
+}