group

2026-05-16 06:49:02 +08:00 · 2022-02-08 20:24:59 +08:00
parent e94dbe4965
commit 02aad295f9
16 changed files with 1399 additions and 709 deletions
@@ -10,7 +10,6 @@ import (
 	commonPb "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
 	"context"
-	"fmt"
 	"strings"

 	pbGroup "Open_IM/pkg/proto/group"
@@ -25,7 +24,7 @@ func GetGroupById(c *gin.Context) {
 		reqPb pbGroup.GetGroupByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError(reqPb.OperationID, "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -34,7 +33,7 @@ func GetGroupById(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroupById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById	 failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -64,7 +63,7 @@ func GetGroups(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroups(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -93,19 +92,18 @@ func GetGroupByName(c *gin.Context) {
 		reqPb pbGroup.GetGroupReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
 	reqPb.GroupName = req.GroupName
 	reqPb.Pagination = &commonPb.RequestPagination{}
 	utils.CopyStructFields(&reqPb.Pagination, req)
-	fmt.Println(reqPb)
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroup(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroup failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -123,13 +121,14 @@ func GetGroupByName(c *gin.Context) {
 	}
 	resp.CurrentPage = int(respPb.Pagination.PageNumber)
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.GroupNums = int(respPb.GroupNums)
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

 func CreateGroup(c *gin.Context) {
 	var (
 		req   cms_api_struct.CreateGroupRequest
-		resp  cms_api_struct.CreateGroupResponse
+		_  cms_api_struct.CreateGroupResponse
 		reqPb pbGroup.CreateGroupReq
 	)
 	if err := c.BindJSON(&req); err != nil {
@@ -140,6 +139,8 @@ func CreateGroup(c *gin.Context) {
 	reqPb.GroupInfo = &commonPb.GroupInfo{}
 	reqPb.GroupInfo.GroupName = req.GroupName
 	reqPb.GroupInfo.CreatorUserID = req.GroupMasterId
+	reqPb.OwnerUserID = req.GroupMasterId
+	reqPb.OpUserID = req.GroupMasterId
 	for _, v := range req.GroupMembers {
 		reqPb.InitMemberList = append(reqPb.InitMemberList, &pbGroup.GroupAddMemberInfo{
 			UserID:    v,
@@ -150,11 +151,11 @@ func CreateGroup(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.CreateGroup(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "CreateGroup failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
-	openIMHttp.RespHttp200(c, constant.OK, resp)
+	openIMHttp.RespHttp200(c, constant.OK, nil)
 }

 func BanGroupChat(c *gin.Context) {
@@ -163,7 +164,7 @@ func BanGroupChat(c *gin.Context) {
 		reqPb pbGroup.OperateGroupStatusReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError(reqPb.OperationID, "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -173,7 +174,7 @@ func BanGroupChat(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BanGroupChat failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -187,7 +188,7 @@ func BanPrivateChat(c *gin.Context) {
 		reqPb pbGroup.OperateGroupStatusReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -197,7 +198,7 @@ func BanPrivateChat(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -210,7 +211,7 @@ func OpenGroupChat(c *gin.Context) {
 		reqPb pbGroup.OperateGroupStatusReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -220,7 +221,7 @@ func OpenGroupChat(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -233,7 +234,7 @@ func OpenPrivateChat(c *gin.Context) {
 		reqPb pbGroup.OperateGroupStatusReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OpenPrivateChat failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -243,7 +244,7 @@ func OpenPrivateChat(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.OperateGroupStatus(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -252,12 +253,12 @@ func OpenPrivateChat(c *gin.Context) {

 func GetGroupMembers(c *gin.Context) {
 	var (
-		req cms_api_struct.GetGroupMembersRequest
+		req  cms_api_struct.GetGroupMembersRequest
 		reqPb pbGroup.GetGroupMembersCMSReq
 		resp   cms_api_struct.GetGroupMembersResponse
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -265,16 +266,21 @@ func GetGroupMembers(c *gin.Context) {
 		PageNumber: int32(req.PageNumber),
 		ShowNumber: int32(req.ShowNumber),
 	}
+	reqPb.GroupId = req.GroupId
+	reqPb.UserName = req.UserName
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS failed:", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
-	resp.ResponsePagination.ShowNumber = int(respPb.Pagination.ShowNumber)
-	resp.ResponsePagination.CurrentPage = int(respPb.Pagination.PageNumber)
+	resp.ResponsePagination = cms_api_struct.ResponsePagination{
+		CurrentPage: int(respPb.Pagination.CurrentPage),
+		ShowNumber:  int(respPb.Pagination.ShowNumber),
+	}
+	resp.MemberNums = int(respPb.MemberNums)
 	for _, groupMembers := range respPb.Members {
 		resp.GroupMembers = append(resp.GroupMembers, cms_api_struct.GroupMemberResponse{
 			MemberPosition: int(groupMembers.RoleLevel),
@@ -294,7 +300,7 @@ func AddGroupMembers(c *gin.Context) {
 		reqPb pbGroup.AddGroupMembersCMSReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(),"BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(),"BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -304,7 +310,7 @@ func AddGroupMembers(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.AddGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(), "AddGroupMembersCMS failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -330,13 +336,13 @@ func RemoveGroupMembers(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.RemoveGroupMembersCMS(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "RemoveGroupMembersCMS failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
 	resp.Success = respPb.Success
 	resp.Failed = respPb.Failed
-	openIMHttp.RespHttp200(c, constant.OK, respPb)
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

 func DeleteGroup(c *gin.Context) {
@@ -350,13 +356,42 @@ func DeleteGroup(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
+	reqPb.GroupId = req.GroupId
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.DeleteGroup(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
 	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func SetGroupMaster(c *gin.Context) {
+	var (
+		req cms_api_struct.SetGroupMasterRequest
+		_ cms_api_struct.SetGroupMasterResponse
+		reqPb pbGroup.SetGroupMasterReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(),"BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	reqPb.GroupId = req.GroupId
+	reqPb.UserId = req.UserId
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	_, err := client.SetGroupMaster(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationId, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}
+
+func GetMemberInGroup(c *gin.Context) {
+
 }
@@ -60,11 +60,14 @@ func NewGinRouter() *gin.Engine {
 		groupRouterGroup.GET("/get_group_members", group.GetGroupMembers)
 		groupRouterGroup.POST("/create_group", group.CreateGroup)
 		groupRouterGroup.POST("/add_members", group.AddGroupMembers)
-		groupRouterGroup.POST("/remove_member", group.RemoveGroupMembers)
+		groupRouterGroup.POST("/remove_members", group.RemoveGroupMembers)
 		groupRouterGroup.POST("/ban_group_private_chat", group.BanPrivateChat)
 		groupRouterGroup.POST("/open_group_private_chat", group.OpenPrivateChat)
 		groupRouterGroup.POST("/ban_group_chat", group.BanGroupChat)
 		groupRouterGroup.POST("/open_group_chat", group.OpenGroupChat)
+		groupRouterGroup.POST("/delete_group", group.DeleteGroup)
+		groupRouterGroup.POST("/get_members_in_group", group.GetMemberInGroup)
+		groupRouterGroup.POST("/set_group_master", group.SetGroupMaster)
 	}
 	userRouterGroup := router.Group("/user")
 	{
@@ -78,6 +81,13 @@ func NewGinRouter() *gin.Engine {
 		userRouterGroup.GET("/get_block_users", user.GetBlockUsers)
 		userRouterGroup.GET("/get_block_user", user.GetBlockUserById)
 		userRouterGroup.POST("/delete_user", user.DeleteUser)
+		userRouterGroup.GET("/get_users_by_name", user.GetUsersByName)
+	}
+	friendRouterGroup := router.Group("/friend")
+	{
+		friendRouterGroup.POST("/get_friends_by_id")
+		friendRouterGroup.POST("/set_friend")
+		friendRouterGroup.POST("/remove_friend")
 	}
 	return baseRouter
 }
@@ -25,7 +25,7 @@ func GetUserById(c *gin.Context) {
 		reqPb pb.GetUserByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("GetUser", utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -34,7 +34,7 @@ func GetUserById(c *gin.Context) {
 	client := pb.NewUserClient(etcdConn)
 	respPb, err := client.GetUserById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("GetUserFailed", utils.GetSelfFuncName(), err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -46,6 +46,38 @@ func GetUserById(c *gin.Context) {
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

+func GetUsersByName(c *gin.Context) {
+	var (
+		req cms_api_struct.GetUsersByNameRequest
+		resp cms_api_struct.GetUsersByNameResponse
+		reqPb pb.GetUsersByNameReq
+	)
+	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.UserName = req.UserName
+	reqPb.Pagination = &commonPb.RequestPagination{
+		PageNumber: int32(req.PageNumber),
+		ShowNumber: int32(req.ShowNumber),
+	}
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName)
+	client := pb.NewUserClient(etcdConn)
+	respPb, err := client.GetUsersByName(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	fmt.Println(respPb)
+	utils.CopyStructFields(&resp.Users, respPb.Users)
+	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
+	openIMHttp.RespHttp200(c, constant.OK, resp)
+}
+
 func GetUsers(c *gin.Context) {
 	var (
 		req   cms_api_struct.GetUsersRequest
@@ -69,6 +101,7 @@ func GetUsers(c *gin.Context) {
 	utils.CopyStructFields(&resp.Users, respPb.User)
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
 	openIMHttp.RespHttp200(c, constant.OK, resp)

 }
@@ -194,12 +227,12 @@ func GetBlockUsers(c *gin.Context) {
 	)
 	reqPb.Pagination = &commonPb.RequestPagination{}
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("0", "BindJSON failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, resp)
 		return
 	}
 	utils.CopyStructFields(&reqPb.Pagination, &req)
-	log.NewInfo("0", "blockUsers", reqPb.Pagination, req)
+	log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "blockUsers", reqPb.Pagination, 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.GetBlockUsers(context.Background(), &reqPb)
@@ -222,6 +255,7 @@ func GetBlockUsers(c *gin.Context) {
 	}
 	resp.ShowNumber = int(respPb.Pagination.ShowNumber)
 	resp.CurrentPage = int(respPb.Pagination.CurrentPage)
+	resp.UserNums = respPb.UserNums
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }

@@ -677,9 +677,15 @@ func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pb
 	}
 	groups, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
-		return nil, err
+		return resp, err
 	}
 	log.NewInfo(req.OperationID, groups)
+	nums, err := imdb.GetGroupsCountNum(db.Group{GroupName:req.GroupName})
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum", err.Error())
+		return resp, err
+	}
+	resp.GroupNums = nums
 	resp.Pagination = &open_im_sdk.RequestPagination{
 		PageNumber: req.Pagination.PageNumber,
 		ShowNumber: req.Pagination.ShowNumber,
@@ -707,7 +713,7 @@ func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pb
 }

 func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) {
-	log.NewInfo(req.OperationID, "GetGroups ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", req.String())
 	resp := &pbGroup.GetGroupsResp{
 		CMSGroups:  []*pbGroup.CMSGroup{},
 		Pagination: &open_im_sdk.RequestPagination{},
@@ -716,8 +722,8 @@ func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*
 	if err != nil {
 		return resp, err
 	}
-	groupsCountNum, err := imdb.GetGroupsCountNum()
-	log.NewInfo(req.OperationID, "groupsCountNum ", groupsCountNum)
+	groupsCountNum, err := imdb.GetGroupsCountNum(db.Group{})
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "groupsCountNum ", groupsCountNum)
 	if err != nil {
 		return resp, err
 	}
@@ -780,11 +786,18 @@ func (s *groupServer) OperateUserRole(_ context.Context, req *pbGroup.OperateUse
 func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGroupMembersCMSReq) (*pbGroup.GetGroupMembersCMSResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:",  req.String())
 	resp := &pbGroup.GetGroupMembersCMSResp{}
-	groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupId, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupId, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(),"GetGroupMembersByGroupIdCMS Error", err.Error())
 		return resp, err
 	}
+	groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupId, req.UserName)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS Error", err.Error())
+		return resp, err
+	}
+	log.NewInfo(req.OperationID, groupMembersCount)
+	resp.MemberNums = groupMembersCount
 	for _, groupMember := range groupMembers {
 		resp.Members = append(resp.Members, &open_im_sdk.GroupMemberFullInfo{
 			GroupID:        req.GroupId,
@@ -796,6 +809,10 @@ func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGrou
 			JoinSource:     groupMember.JoinSource,
 		})
 	}
+	resp.Pagination = &open_im_sdk.ResponsePagination{
+		CurrentPage: req.Pagination.PageNumber,
+		ShowNumber:  req.Pagination.ShowNumber,
+	}
 	return resp, nil
 }

@@ -815,7 +832,7 @@ func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.Remo
 }

 func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGroupMembersCMSReq) (*pbGroup.AddGroupMembersCMSResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
+	log.NewInfo(req.OperationId, utils.GetSelfFuncName(), "args:", req.String())
 	resp := &pbGroup.AddGroupMembersCMSResp{}
 	for _, userIds := range req.UserIds {
 		groupMember := db.GroupMember{
@@ -830,6 +847,7 @@ func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGrou
 			Ex:             "",
 		}
 		if err := imdb.InsertIntoGroupMember(groupMember); err != nil {
+			log.NewError(req.OperationId, utils.GetSelfFuncName(), "InsertIntoGroupMember failed", req.String())
 			resp.Failed = append(resp.Failed, userIds)
 		} else  {
 			resp.Success = append(resp.Success, userIds)
@@ -837,3 +855,14 @@ func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGrou
 	}
 	return resp, nil
 }
+
+func (s *groupServer) SetGroupMaster(_ context.Context, req *pbGroup.SetGroupMasterReq) (*pbGroup.SetGroupMasterResp, error) {
+	log.NewInfo(req.OperationId, utils.GetSelfFuncName(), req.String())
+	resp := &pbGroup.SetGroupMasterResp{}
+	err := imdb.OperateGroupRole(req.UserId, req.GroupId, constant.GroupOwner)
+	if err != nil {
+		log.NewError(req.OperationId, utils.GetSelfFuncName(),"OperateGroupRole failed", err.Error())
+		return resp, nil
+	}
+	return resp, nil
+}
@@ -3,7 +3,7 @@ package statistics
 import (
 	"Open_IM/pkg/common/config"
 	"context"
-	"fmt"
+	"sync"
 	"time"

 	//"Open_IM/pkg/common/constant"
@@ -73,16 +73,16 @@ func (s *statisticsServer) Run() {
 }

 func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.GetActiveGroupReq) (*pbStatistics.GetActiveGroupResp, error) {
-	log.NewInfo("GetActiveGroup", utils.GetSelfFuncName(), req.String())
+	log.NewInfo(req.OperationID, 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())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12)
 	if err != nil {
-		log.NewError("GetActiveGroup", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	for _, activeGroup := range activeGroups {
@@ -97,16 +97,16 @@ func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.G
 }

 func (s *statisticsServer) GetActiveUser(_ context.Context, req *pbStatistics.GetActiveUserReq) (*pbStatistics.GetActiveUserResp, error) {
-	log.NewInfo("GetActiveUser", utils.GetSelfFuncName(), req.String())
+	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("GetActiveUser", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	activeUsers, err := imdb.GetActiveUsers(fromTime, toTime, 12)
 	if err != nil {
-		log.NewError("GetActiveUser", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	for _, activeUser := range activeUsers {
@@ -136,7 +136,7 @@ func ParseTimeFromTo(from, to string) (time.Time, time.Time, error) {
 }

 func isInOneMonth(from, to time.Time) bool {
-	return from.Month() == to.Month()
+	return from.Month() == to.Month() && from.Year() == to.Year()
 }

 func GetRangeDate(from, to time.Time) [][2]time.Time {
@@ -195,144 +195,167 @@ func getFirstDateOfNextNMonth(currentTime time.Time, n int) time.Time {
 }

 func (s *statisticsServer) GetGroupStatistics(_ context.Context, req *pbStatistics.GetGroupStatisticsReq) (*pbStatistics.GetGroupStatisticsResp, error) {
-	log.NewInfo("GetGroupStatistics", utils.GetSelfFuncName(), req.String())
+	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("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, 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())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	totalGroupNum, err := imdb.GetTotalGroupNum()
 	if err != nil {
-		log.NewError("GetMessageStatistics", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, 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,
-		})
+	log.NewInfo(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))
+	log.NewInfo(req.OperationID, resp.TotalGroupNumList, resp.TotalGroupNumList)
+	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[0])
+			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()
 	return resp, nil
 }

 func (s *statisticsServer) GetMessageStatistics(_ context.Context, req *pbStatistics.GetMessageStatisticsReq) (*pbStatistics.GetMessageStatisticsResp, error) {
-	log.NewInfo("GetMessageStatistics", utils.GetSelfFuncName(), req.String())
+	log.NewInfo(req.OperationID, 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())
+		log.NewError(req.OperationID, 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())
+		log.NewError(req.OperationID, 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())
+		log.NewError(req.OperationID, 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,
-		})
+	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)
 	}
-	fmt.Println(resp)
+	wg.Wait()
 	return resp, nil
 }

 func (s *statisticsServer) GetUserStatistics(_ context.Context, req *pbStatistics.GetUserStatisticsReq) (*pbStatistics.GetUserStatisticsResp, error) {
-	log.NewInfo("GetUserStatistics", utils.GetSelfFuncName(), req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), 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", err.Error())
 		return resp, err
 	}
 	activeUserNum, err := imdb.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24))
 	if err != nil {
-		log.NewError("GetUserStatistics", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUserNum", 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())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum error", err.Error())
 		return resp, err
 	}
 	totalUserNum, err := imdb.GetTotalUserNum()
 	if err != nil {
-		log.NewError("GetUserStatistics", utils.GetSelfFuncName(), err.Error())
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNum error", 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,
-		})
+	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[0])
+			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()
 	return resp, nil
 }
@@ -243,8 +243,44 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI
 	return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil
 }

+func (s *userServer) GetUsersByName(ctx context.Context, req *pbUser.GetUsersByNameReq) (*pbUser.GetUsersByNameResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String())
+	resp := &pbUser.GetUsersByNameResp{}
+	users, err := imdb.GetUserByName(req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByName failed", err.Error())
+		return resp, err
+	}
+	for _, user := range users {
+		isBlock, err := imdb.UserIsBlock(user.UserID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		resp.Users = append(resp.Users, &pbUser.User{
+			ProfilePhoto: user.FaceURL,
+			Nickname:     user.Nickname,
+			UserId:       user.UserID,
+			CreateTime:   user.CreateTime.String(),
+			IsBlock:      isBlock,
+		})
+	}
+	user := db.Users{Nickname:req.UserName}
+	userNums, err := imdb.GetUsersCount(user)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "", err.Error())
+		return resp, err
+	}
+	resp.UserNums = userNums
+	resp.Pagination = &sdkws.ResponsePagination{
+		CurrentPage: req.Pagination.PageNumber,
+		ShowNumber:  req.Pagination.ShowNumber,
+	}
+	return resp, err
+}
+
 func (s *userServer) GetUserById(ctx context.Context, req *pbUser.GetUserByIdReq) (*pbUser.GetUserByIdResp, error) {
-	log.NewInfo(req.OperationID, "GetUser args ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String())
 	resp := &pbUser.GetUserByIdResp{User: &pbUser.User{}}
 	user, err := imdb.GetUserByUserID(req.UserId)
 	if err != nil {
@@ -284,10 +320,14 @@ func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pb
 			resp.User = append(resp.User, user)
 		}
 	}
-
-	resp.Pagination = &sdkws.ResponsePagination{}
-	resp.Pagination.ShowNumber = req.Pagination.ShowNumber
-	resp.Pagination.CurrentPage = req.Pagination.PageNumber
+	user := db.Users{}
+	nums, err := imdb.GetUsersCount(user)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUsersCount failed", err.Error())
+		return resp, err
+	}
+	resp.UserNums = nums
+	resp.Pagination = &sdkws.ResponsePagination{ShowNumber:req.Pagination.ShowNumber, CurrentPage:req.Pagination.ShowNumber}
 	return resp, nil
 }

@@ -369,7 +409,12 @@ func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUser
 	resp.Pagination = &sdkws.ResponsePagination{}
 	resp.Pagination.ShowNumber = req.Pagination.ShowNumber
 	resp.Pagination.CurrentPage = req.Pagination.PageNumber
-	fmt.Println(resp)
+	nums, err := imdb.GetBlockUsersNumCount()
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetBlockUsersNumCount failed", err.Error())
+		return resp, err
+	}
+	resp.UserNums = nums
 	return resp, nil
 }

@@ -398,8 +443,9 @@ func (s *userServer) DeleteUser(_ context.Context, req *pbUser.DeleteUserReq) (*
 	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)
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), "delete failed", "delete rows:", row)
 		return resp, constant.ErrDB
 	}
 	return resp, nil
 }
+