cms dev

internal/api/group/group.go

@@ -331,7 +331,6 @@ func GetGroupsInfo(c *gin.Context) {
 		return
 	}
 	log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String())
-
 	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
 	client := rpc.NewGroupClient(etcdConn)
 	RpcResp, err := client.GetGroupsInfo(context.Background(), req)
@@ -504,5 +503,4 @@ func TransferGroupOwner(c *gin.Context) {
 	resp := api.TransferGroupOwnerResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
 	log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp)
 	c.JSON(http.StatusOK, resp)
-
 }

internal/cms_api/group/group.go

@@ -25,24 +25,25 @@ func GetGroupById(c *gin.Context) {
 		reqPb pbGroup.GetGroupByIdReq
 	)
 	if err := c.ShouldBindQuery(&req); err != nil {
-		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, "ShouldBindQuery failed ", err.Error())
 		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)
 	respPb, err := client.GetGroupById(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError(utils.GetSelfFuncName(), "GetGroupById	 failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById	 failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
-	resp.GroupMasterId = respPb.GroupInfo.OwnerUserID
-	resp.GroupName = respPb.GroupInfo.GroupName
-	resp.GroupID = respPb.GroupInfo.GroupID
-	resp.CreateTime = (utils.UnixSecondToTime(int64(respPb.GroupInfo.CreateTime))).String()
-	resp.ProfilePhoto = respPb.GroupInfo.FaceURL
-	resp.GroupMasterName = respPb.GroupInfo.OwnerUserID
+	resp.GroupName = respPb.CMSGroup.GroupInfo.GroupName
+	resp.GroupID = respPb.CMSGroup.GroupInfo.GroupID
+	resp.CreateTime = (utils.UnixSecondToTime(int64(respPb.CMSGroup.GroupInfo.CreateTime))).String()
+	resp.ProfilePhoto = respPb.CMSGroup.GroupInfo.FaceURL
+	resp.GroupMasterName = respPb.CMSGroup.GroupMasterName
+	resp.GroupMasterId = respPb.CMSGroup.GroupMasterId
 	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
@@ -53,7 +54,7 @@ func GetGroups(c *gin.Context) {
 		reqPb pbGroup.GetGroupsReq
 	)
 	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
 	}
@@ -63,20 +64,20 @@ func GetGroups(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	respPb, err := client.GetGroups(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
-	for _, v := range respPb.GroupInfo {
+	for _, v := range respPb.CMSGroups {
 		resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{
-			GroupName:        v.GroupName,
-			GroupID:          v.GroupID,
-			GroupMasterName:  v.OwnerUserID,
-			GroupMasterId:    v.OwnerUserID,
-			CreateTime:       (utils.UnixSecondToTime(int64(v.CreateTime))).String(),
+			GroupName:        v.GroupInfo.GroupName,
+			GroupID:          v.GroupInfo.GroupID,
+			GroupMasterName:  v.GroupMasterName,
+			GroupMasterId:    v.GroupMasterId,
+			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
 			IsBanChat:        false,
 			IsBanPrivateChat: false,
-			ProfilePhoto:     v.FaceURL,
+			ProfilePhoto:     v.GroupInfo.FaceURL,
 		})
 	}
 	resp.GroupNums = int(respPb.GroupNum)
@@ -108,16 +109,16 @@ func GetGroupByName(c *gin.Context) {
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
-	for _, v := range respPb.GroupInfo {
+	for _, v := range respPb.CMSGroups {
 		resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{
-			GroupName:        v.GroupName,
-			GroupID:          v.GroupID,
-			GroupMasterName:  v.OwnerUserID,
-			GroupMasterId:    v.OwnerUserID,
-			CreateTime:       (utils.UnixSecondToTime(int64(v.CreateTime))).String(),
+			GroupName:        v.GroupInfo.GroupName,
+			GroupID:          v.GroupInfo.GroupID,
+			GroupMasterName:  v.GroupMasterName,
+			GroupMasterId:    v.GroupMasterId,
+			CreateTime:       (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(),
 			IsBanChat:        false,
 			IsBanPrivateChat: false,
-			ProfilePhoto:     v.FaceURL,
+			ProfilePhoto:     v.GroupInfo.FaceURL,
 		})
 	}
 	resp.CurrentPage = int(respPb.Pagination.PageNumber)
@@ -132,7 +133,7 @@ func CreateGroup(c *gin.Context) {
 		reqPb pbGroup.CreateGroupReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -149,7 +150,7 @@ func CreateGroup(c *gin.Context) {
 	client := pbGroup.NewGroupClient(etcdConn)
 	_, err := client.CreateGroup(context.Background(), &reqPb)
 	if err != nil {
-		log.NewError("s", "GetUserInfo failed ", err.Error())
+		log.NewError(reqPb.OperationID, "GetUserInfo failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -162,7 +163,7 @@ func BanGroupChat(c *gin.Context) {
 		reqPb pbGroup.OperateGroupStatusReq
 	)
 	if err := c.BindJSON(&req); err != nil {
-		log.NewError("0", "ShouldBindQuery failed ", err.Error())
+		log.NewError(reqPb.OperationID, "ShouldBindQuery failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
@@ -172,7 +173,7 @@ func BanGroupChat(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, "GetUserInfo failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
@@ -242,41 +243,120 @@ func OpenPrivateChat(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, "GetUserInfo failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
 		return
 	}
 	openIMHttp.RespHttp200(c, constant.OK, nil)
 }
 
-func GetGroupsMember(c *gin.Context) {
+func GetGroupMembers(c *gin.Context) {
 	var (
 		req cms_api_struct.GetGroupMembersRequest
-		_   cms_api_struct.GetGroupMembersResponse
+		reqPb pbGroup.GetGroupMembersCMSReq
+		resp   cms_api_struct.GetGroupMembersResponse
 	)
-	if err := c.BindJSON(&req); err != nil {
+	if err := c.ShouldBindQuery(&req); err != nil {
 		log.NewError("0", "BindJSON failed ", err.Error())
 		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
 		return
 	}
+	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.OpenImGroupName)
+	client := pbGroup.NewGroupClient(etcdConn)
+	respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	resp.ResponsePagination.ShowNumber = int(respPb.Pagination.ShowNumber)
+	resp.ResponsePagination.CurrentPage = int(respPb.Pagination.PageNumber)
+	for _, groupMembers := range respPb.Members {
+		resp.GroupMembers = append(resp.GroupMembers, cms_api_struct.GroupMemberResponse{
+			MemberPosition: int(groupMembers.RoleLevel),
+			MemberNickName: groupMembers.Nickname,
+			MemberId:       groupMembers.UserID,
+			JoinTime:      utils.UnixSecondToTime(groupMembers.JoinTime).String(),
+		})
+	}
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
-func InquireGroup(c *gin.Context) {
 
+func AddGroupMembers(c *gin.Context) {
+	var (
+		req cms_api_struct.RemoveGroupMembersRequest
+		resp cms_api_struct.RemoveGroupMembersResponse
+		reqPb pbGroup.AddGroupMembersCMSReq
+	)
+	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.UserIds = req.Members
+	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)
+	respPb, err := client.AddGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	resp.Success = respPb.Success
+	resp.Failed = respPb.Failed
+	openIMHttp.RespHttp200(c, constant.OK, resp)
 }
 
-func AddMembers(c *gin.Context) {
-
+func RemoveGroupMembers(c *gin.Context) {
+	var (
+		req cms_api_struct.RemoveGroupMembersRequest
+		resp cms_api_struct.RemoveGroupMembersResponse
+		reqPb pbGroup.RemoveGroupMembersCMSReq
+	)
+	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.UserIds = req.Members
+	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)
+	respPb, err := client.RemoveGroupMembersCMS(context.Background(), &reqPb)
+	if err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc:", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	resp.Success = respPb.Success
+	resp.Failed = respPb.Failed
+	openIMHttp.RespHttp200(c, constant.OK, respPb)
 }
 
-func RemoveUser(c *gin.Context) {
-
-}
-
-func Withdraw(c *gin.Context) {
-
-}
-
-func SearchMessage(g *gin.Context) {
-
-}
+func DeleteGroup(c *gin.Context) {
+	var (
+		req cms_api_struct.DeleteGroupRequest
+		_ cms_api_struct.DeleteGroupResponse
+		reqPb pbGroup.DeleteGroupReq
+	)
+	if err := c.BindJSON(&req); err != nil {
+		log.NewError(reqPb.OperationID, utils.GetSelfFuncName(),"BindJSON failed ", err.Error())
+		openIMHttp.RespHttp200(c, constant.ErrArgs, nil)
+		return
+	}
+	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())
+		openIMHttp.RespHttp200(c, constant.ErrServer, nil)
+		return
+	}
+	openIMHttp.RespHttp200(c, constant.OK, nil)
+}

internal/cms_api/router.go

@@ -57,29 +57,26 @@ func NewGinRouter() *gin.Engine {
 		groupRouterGroup.GET("/get_group_by_id", group.GetGroupById)
 		groupRouterGroup.GET("/get_groups", group.GetGroups)
 		groupRouterGroup.GET("/get_group_by_name", group.GetGroupByName)
-		groupRouterGroup.GET("/get_group_members", group.GetGroupsMember)
+		groupRouterGroup.GET("/get_group_members", group.GetGroupMembers)
 		groupRouterGroup.POST("/create_group", group.CreateGroup)
-		groupRouterGroup.GET("/inquire_group", group.InquireGroup)
-		groupRouterGroup.POST("/add_members", group.AddMembers)
-		groupRouterGroup.POST("/remove_member", group.RemoveUser)
+		groupRouterGroup.POST("/add_members", group.AddGroupMembers)
+		groupRouterGroup.POST("/remove_member", group.RemoveGroupMembers)
 		groupRouterGroup.POST("/ban_group_private_chat", group.BanPrivateChat)
 		groupRouterGroup.POST("/open_group_private_chat", group.OpenPrivateChat)
-		groupRouterGroup.POST("/withdraw_message", group.Withdraw)
-		groupRouterGroup.POST("/search_group_message", group.SearchMessage)
 		groupRouterGroup.POST("/ban_group_chat", group.BanGroupChat)
 		groupRouterGroup.POST("/open_group_chat", group.OpenGroupChat)
 	}
 	userRouterGroup := router.Group("/user")
 	{
 		userRouterGroup.POST("/resign", user.ResignUser)
-		userRouterGroup.GET("/get_user_by_id", user.GetUserById)
+		userRouterGroup.GET("/get_user", 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_by_id", user.GetBlockUserById)
+		userRouterGroup.GET("/get_block_user", user.GetBlockUserById)
 		userRouterGroup.POST("/delete_user", user.DeleteUser)
 	}
 	return baseRouter

internal/rpc/group/group.go

@@ -641,13 +641,16 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe
 }
 
 func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdReq) (*pbGroup.GetGroupByIdResp, error) {
-	log.NewInfo(req.OperationID, "GetGroup ", req.String())
-	resp := &pbGroup.GetGroupByIdResp{}
+	log.NewInfo(req.OperationID,  utils.GetSelfFuncName(), "GetGroup ", req.String())
+	resp := &pbGroup.GetGroupByIdResp{CMSGroup: &pbGroup.CMSGroup{
+		GroupInfo:	&open_im_sdk.GroupInfo{},
+	}}
 	group, err := imdb.GetGroupsById(req.GroupId)
 	if err != nil {
+		log.NewInfo(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
-	resp.GroupInfo = &open_im_sdk.GroupInfo{
+	resp.CMSGroup.GroupInfo = &open_im_sdk.GroupInfo{
 		GroupID:       group.GroupID,
 		GroupName:     group.GroupName,
 		FaceURL:       group.FaceUrl,
@@ -657,31 +660,47 @@ func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdR
 		CreatorUserID: group.CreatorUserID,
 		GroupType:     group.GroupType,
 	}
-	resp.GroupInfo.CreatorUserID = group.CreatorUserID
+	groupMember, err := imdb.GetGroupMaster(group.GroupID)
+	if err != nil {
+		return resp, err
+	}
+	resp.CMSGroup.GroupMasterName = groupMember.Nickname
+	resp.CMSGroup.GroupMasterId = groupMember.UserID
+	resp.CMSGroup.GroupInfo.CreatorUserID = group.CreatorUserID
 	return resp, nil
 }
 
 func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pbGroup.GetGroupResp, error) {
 	log.NewInfo(req.OperationID, "GetGroup ", req.String())
 	resp := &pbGroup.GetGroupResp{
-		GroupInfo: []*open_im_sdk.GroupInfo{},
+		CMSGroups: []*pbGroup.CMSGroup{},
 	}
 	groups, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 	if err != nil {
 		return nil, err
 	}
+	log.NewInfo(req.OperationID, groups)
 	resp.Pagination = &open_im_sdk.RequestPagination{
 		PageNumber: req.Pagination.PageNumber,
 		ShowNumber: req.Pagination.ShowNumber,
 	}
 	for _, v := range groups {
-		resp.GroupInfo = append(resp.GroupInfo, &open_im_sdk.GroupInfo{
-			GroupID:       v.GroupID,
-			GroupName:     v.GroupName,
-			FaceURL:       v.FaceUrl,
-			OwnerUserID:   v.CreatorUserID,
-			Status:        v.Status,
-			CreatorUserID: v.CreatorUserID,
+		groupMember, err := imdb.GetGroupMaster(v.GroupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{
+			GroupInfo: &open_im_sdk.GroupInfo{
+				GroupID:       v.GroupID,
+				GroupName:     v.GroupName,
+				FaceURL:       v.FaceUrl,
+				OwnerUserID:   v.CreatorUserID,
+				Status:        v.Status,
+				CreatorUserID: v.CreatorUserID,
+			},
+			GroupMasterName: groupMember.Nickname,
+			GroupMasterId: groupMember.UserID,
 		})
 	}
 	return resp, nil
@@ -690,7 +709,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())
 	resp := &pbGroup.GetGroupsResp{
-		GroupInfo:  []*open_im_sdk.GroupInfo{},
+		CMSGroups:  []*pbGroup.CMSGroup{},
 		Pagination: &open_im_sdk.RequestPagination{},
 	}
 	groups, err := imdb.GetGroups(int(req.Pagination.PageNumber), int(req.Pagination.ShowNumber))
@@ -706,13 +725,22 @@ func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*
 	resp.Pagination.PageNumber = req.Pagination.PageNumber
 	resp.Pagination.ShowNumber = req.Pagination.ShowNumber
 	for _, v := range groups {
-		resp.GroupInfo = append(resp.GroupInfo, &open_im_sdk.GroupInfo{
-			GroupID:       v.GroupID,
-			GroupName:     v.GroupName,
-			FaceURL:       v.FaceUrl,
-			OwnerUserID:   v.CreatorUserID,
-			Status:        v.Status,
-			CreatorUserID: v.CreatorUserID,
+		groupMember, err := imdb.GetGroupMaster(v.GroupID)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+			continue
+		}
+		resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{
+			GroupInfo: &open_im_sdk.GroupInfo{
+				GroupID:       v.GroupID,
+				GroupName:     v.GroupName,
+				FaceURL:       v.FaceUrl,
+				OwnerUserID:   v.CreatorUserID,
+				Status:        v.Status,
+				CreatorUserID: v.CreatorUserID,
+			},
+			GroupMasterId: groupMember.UserID,
+			GroupMasterName: groupMember.Nickname,
 		})
 	}
 
@@ -723,6 +751,7 @@ func (s *groupServer) OperateGroupStatus(_ context.Context, req *pbGroup.Operate
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
 	resp := &pbGroup.OperateGroupStatusResp{}
 	if err := imdb.OperateGroupStatus(req.GroupId, req.Status); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	return resp, nil
@@ -732,16 +761,79 @@ func (s *groupServer) DeleteGroup(_ context.Context, req *pbGroup.DeleteGroupReq
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String())
 	resp := &pbGroup.DeleteGroupResp{}
 	if err := imdb.DeleteGroup(req.GroupId); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	return resp, nil
 }
 
 func (s *groupServer) OperateUserRole(_ context.Context, req *pbGroup.OperateUserRoleReq) (*pbGroup.OperateUserRoleResp, error) {
-	log.NewInfo(req.OperationID, "DeleteGroup ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
 	resp := &pbGroup.OperateUserRoleResp{}
 	if err := imdb.OperateGroupRole(req.UserId, req.GroupId, req.RoleLevel); err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
 		return resp, err
 	}
 	return resp, nil
 }
+
+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)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+		return resp, err
+	}
+	for _, groupMember := range groupMembers {
+		resp.Members = append(resp.Members, &open_im_sdk.GroupMemberFullInfo{
+			GroupID:        req.GroupId,
+			UserID:         groupMember.UserID,
+			RoleLevel:      groupMember.RoleLevel,
+			JoinTime:       groupMember.JoinTime.Unix(),
+			Nickname:       groupMember.Nickname,
+			FaceURL:        groupMember.FaceUrl,
+			JoinSource:     groupMember.JoinSource,
+		})
+	}
+	return resp, nil
+}
+
+func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.RemoveGroupMembersCMSReq) (*pbGroup.RemoveGroupMembersCMSResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
+	resp := &pbGroup.RemoveGroupMembersCMSResp{}
+	for _, userId := range req.UserIds {
+		err := imdb.RemoveGroupMember(req.GroupId, userId)
+		if err != nil {
+			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
+			resp.Failed = append(resp.Failed, userId)
+		} else {
+			resp.Success = append(resp.Success, userId)
+		}
+	}
+	return resp, nil
+}
+
+func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGroupMembersCMSReq) (*pbGroup.AddGroupMembersCMSResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String())
+	resp := &pbGroup.AddGroupMembersCMSResp{}
+	for _, userIds := range req.UserIds {
+		groupMember := db.GroupMember{
+			GroupID:        req.GroupId,
+			UserID:         userIds,
+			Nickname:       "",
+			FaceUrl:        "",
+			RoleLevel:      1,
+			JoinTime:       time.Time{},
+			JoinSource:     constant.JoinByAdmin,
+			OperatorUserID: "CmsAdmin",
+			Ex:             "",
+		}
+		if err := imdb.InsertIntoGroupMember(groupMember); err != nil {
+			resp.Failed = append(resp.Failed, userIds)
+		} else  {
+			resp.Success = append(resp.Success, userIds)
+		}
+	}
+	return resp, nil
+}

internal/rpc/user/user.go

@@ -374,7 +374,7 @@ func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUser
 }
 
 func (s *userServer) GetBlockUserById(_ context.Context, req *pbUser.GetBlockUserByIdReq) (*pbUser.GetBlockUserByIdResp, error) {
-	log.NewInfo(req.OperationID, "GetBlockUser args ", req.String())
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetBlockUserById args ", req.String())
 	resp := &pbUser.GetBlockUserByIdResp{}
 	user, err := imdb.GetBlockUserById(req.UserId)
 	if err != nil {