group

internal/rpc/group/group.go

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

internal/rpc/statistics/statistics.go

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

internal/rpc/user/user.go

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