Merge branch 'tuoyun' of github.com:OpenIMSDK/Open-IM-Server into tuoyun

# Conflicts:
#	pkg/common/constant/constant.go

cmd/Open-IM-SDK-Core

@@ -1 +1 @@
-Subproject commit a4b710de8df31fe570fd90895887edef30f3a64c
+Subproject commit 3ecd23203cd6bd746b1fcb0c70755bd2cbf5361c

cmd/open_im_api/main.go

@@ -8,6 +8,7 @@ import (
 	"Open_IM/internal/api/group"
 	"Open_IM/internal/api/manage"
 	"Open_IM/internal/api/office"
+	"Open_IM/internal/api/organization"
 	apiThird "Open_IM/internal/api/third"
 	"Open_IM/internal/api/user"
 	"Open_IM/pkg/common/config"
@@ -37,9 +38,10 @@ func main() {
 	// user routing group, which handles user registration and login services
 	userRouterGroup := r.Group("/user")
 	{
-		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)    //1
+		userRouterGroup.POST("/update_user_info", user.UpdateUserInfo)              //1
-		userRouterGroup.POST("/get_users_info", user.GetUsersInfo)        //1
+		userRouterGroup.POST("/get_users_info", user.GetUsersInfo)                  //1
-		userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1
+		userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo)           //1
+		userRouterGroup.POST("/get_users_online_status", user.GetUsersOnlineStatus) //1
 	}
 	//friend routing group
 	friendRouterGroup := r.Group("/friend")
@@ -83,6 +85,9 @@ func main() {
 		groupRouterGroup.POST("/cancel_mute_group_member", group.CancelMuteGroupMember) //MuteGroup
 		groupRouterGroup.POST("/mute_group", group.MuteGroup)
 		groupRouterGroup.POST("/cancel_mute_group", group.CancelMuteGroup)
+
+		groupRouterGroup.POST("/set_group_member_nickname", group.SetGroupMemberNickname)
+
 	}
 	//certificate
 	authRouterGroup := r.Group("/auth")
@@ -147,6 +152,26 @@ func main() {
 		officeGroup.POST("/clear_user_work_moments_comments_msg", office.ClearUserWorkMomentsCommentsMsg)
 		officeGroup.POST("/set_user_work_moments_level", office.SetUserWorkMomentsLevel)
 	}
+
+	organizationGroup := r.Group("/organization")
+	{
+		organizationGroup.POST("/create_department", organization.CreateDepartment)
+		organizationGroup.POST("/update_department", organization.UpdateDepartment)
+		organizationGroup.POST("/get_sub_department", organization.GetSubDepartment)
+		organizationGroup.POST("/delete_department", organization.DeleteDepartment)
+
+		organizationGroup.POST("/create_organization_user", organization.CreateOrganizationUser)
+		organizationGroup.POST("/update_organization_user", organization.UpdateOrganizationUser)
+		organizationGroup.POST("/delete_organization_user", organization.DeleteOrganizationUser)
+
+		organizationGroup.POST("/create_department_member", organization.CreateDepartmentMember)
+		organizationGroup.POST("/get_user_in_department", organization.GetUserInDepartment)
+		organizationGroup.POST("/update_user_in_department", organization.UpdateUserInDepartment)
+
+		organizationGroup.POST("/get_department_member", organization.GetDepartmentMember)
+		organizationGroup.POST("/delete_user_in_department", organization.DeleteUserInDepartment)
+	}
+
 	go apiThird.MinioInit()
 	ginPort := flag.Int("port", 10000, "get ginServerPort from cmd,default 10000 as port")
 	flag.Parse()

cmd/rpc/open_im_organization/Makefile

@@ -0,0 +1,25 @@
+.PHONY: all build run gotool install clean help
+
+BINARY_NAME=open_im_organization
+BIN_DIR=../../../bin/
+
+all: gotool build
+
+build:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-w -s"
+
+run:
+	@go run ./
+
+gotool:
+	go fmt ./
+	go vet ./
+
+install:
+	make build
+	mv ${BINARY_NAME} ${BIN_DIR}
+
+clean:
+	@if [ -f ${BINARY_NAME} ] ; then rm ${BINARY_NAME} ; fi
+
+

cmd/rpc/open_im_organization/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"Open_IM/internal/rpc/organization"
+	"flag"
+	"fmt"
+)
+
+func main() {
+	rpcPort := flag.Int("port", 11200, "get RpcOrganizationPort from cmd,default 11200 as port")
+	flag.Parse()
+	fmt.Println("start organization rpc server, port: ", *rpcPort)
+	rpcServer := organization.NewServer(*rpcPort)
+	rpcServer.Run()
+}

config/config.yaml

@@ -122,6 +122,7 @@ rpcport: #rpc服务端口 默认即可
   openImMessageCmsPort: [ 10900 ]
   openImAdminCmsPort: [ 11000 ]
   openImOfficePort: [ 11100 ]
+  openImOrganizationPort: [ 11200 ]
   c2c:
     callbackBeforeSendMsg:
       switch: false
@@ -144,6 +145,7 @@ rpcregistername: #rpc注册服务名，默认即可
   OpenImMessageCMSName: MessageCMS
   openImAdminCMSName: AdminCMS
   openImOfficeName: Office
+  openImOrganizationName: Organization
 
 log:
   storageLocation: ../logs/
@@ -430,6 +432,20 @@ notification:
       ext: "groupMemberCancelMuted ext"
     defaultTips:
       tips: "group Member Cancel Muted"
+
+  groupMemberInfoSet:
+    conversation:
+      reliabilityLevel: 2
+      unreadCount: false
+    offlinePush:
+      switch: false
+      title: "groupMemberInfoSet title"
+      desc: "groupMemberInfoSet desc"
+      ext: "groupMemberInfoSet ext"
+    defaultTips:
+      tips: "group member info set"
+
+
   #############################friend#################################
 
   friendApplicationAdded:

internal/api/group/group.go

@@ -696,3 +696,37 @@ func CancelMuteGroup(c *gin.Context) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
 	c.JSON(http.StatusOK, resp)
 }
+
+//SetGroupMemberNickname
+
+func SetGroupMemberNickname(c *gin.Context) {
+	params := api.SetGroupMemberNicknameReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.SetGroupMemberNicknameReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api args ", req.String())
+
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName)
+	client := rpc.NewGroupClient(etcdConn)
+	reply, err := client.SetGroupMemberNickname(context.Background(), req)
+	if err != nil {
+		log.NewError(req.OperationID, utils.GetSelfFuncName(), " failed ", req.String())
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": err.Error()})
+		return
+	}
+
+	resp := api.SetGroupMemberNicknameResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " api return ", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/api/manage/management_user.go

@@ -118,6 +118,7 @@ func AccountCheck(c *gin.Context) {
 	log.NewInfo(req.OperationID, "AccountCheck api return", resp)
 	c.JSON(http.StatusOK, resp)
 }
+
 func GetUsersOnlineStatus(c *gin.Context) {
 	params := api.GetUsersOnlineStatusReq{}
 	if err := c.BindJSON(&params); err != nil {
@@ -133,6 +134,12 @@ func GetUsersOnlineStatus(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
 		return
 	}
+	if len(config.Config.Manager.AppManagerUid) == 0 {
+		log.NewError(req.OperationID, "Manager == 0")
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "Manager == 0"})
+		return
+	}
+	req.OpUserID = config.Config.Manager.AppManagerUid[0]
 	log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
 	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
 	var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
@@ -176,5 +183,4 @@ func GetUsersOnlineStatus(c *gin.Context) {
 	}
 	log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
 	c.JSON(http.StatusOK, resp)
-
 }

internal/api/organization/organization.go

@@ -0,0 +1,439 @@
+package organization
+
+import (
+	jsonData "Open_IM/internal/utils"
+	api "Open_IM/pkg/base_info"
+	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	rpc "Open_IM/pkg/proto/organization"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+	"Open_IM/pkg/utils"
+	"context"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func CreateDepartment(c *gin.Context) {
+	params := api.CreateDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.CreateDepartmentReq{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.DepartmentInfo, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + " " + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, Department: RpcResp.DepartmentInfo}
+	apiResp.Data = jsonData.JsonDataOne(RpcResp.DepartmentInfo)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateDepartment(c *gin.Context) {
+	params := api.UpdateDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.UpdateDepartmentReq{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.DepartmentInfo, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetSubDepartment(c *gin.Context) {
+	params := api.GetSubDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.GetSubDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetSubDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetSubDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, DepartmentList: RpcResp.DepartmentList}
+	apiResp.Data = jsonData.JsonDataList(RpcResp.DepartmentList)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteDepartment(c *gin.Context) {
+	params := api.DeleteDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.DeleteDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func CreateOrganizationUser(c *gin.Context) {
+	params := api.CreateOrganizationUserReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.CreateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.OrganizationUser, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateOrganizationUser(c *gin.Context) {
+	params := api.UpdateOrganizationUserReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.UpdateOrganizationUserReq{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.OrganizationUser, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func CreateDepartmentMember(c *gin.Context) {
+	params := api.CreateDepartmentMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.CreateDepartmentMemberReq{DepartmentMember: &open_im_sdk.DepartmentMember{}}
+	utils.CopyStructFields(req, &params)
+	utils.CopyStructFields(req.DepartmentMember, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.CreateDepartmentMember(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc CreateDepartmentMember failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.CreateDepartmentMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetUserInDepartment(c *gin.Context) {
+	params := api.GetUserInDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.GetUserInDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetUserInDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, UserInDepartment: RpcResp.UserInDepartment}
+	apiResp.Data = jsonData.JsonDataOne(RpcResp.UserInDepartment)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func UpdateUserInDepartment(c *gin.Context) {
+	params := api.UpdateUserInDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.UpdateUserInDepartmentReq{DepartmentMember: &open_im_sdk.DepartmentMember{}}
+	utils.CopyStructFields(req.DepartmentMember, &params)
+	utils.CopyStructFields(req, &params)
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.UpdateUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc UpdateUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.UpdateUserInDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteOrganizationUser(c *gin.Context) {
+	params := api.DeleteOrganizationUserReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.DeleteOrganizationUserReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteOrganizationUser(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteOrganizationUser failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.DeleteOrganizationUserResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func GetDepartmentMember(c *gin.Context) {
+	params := api.GetDepartmentMemberReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+
+	req := &rpc.GetDepartmentMemberReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.GetDepartmentMember(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc GetDepartmentMember failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.GetDepartmentMemberResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}, UserInDepartmentList: RpcResp.UserDepartmentMemberList}
+	apiResp.Data = jsonData.JsonDataList(RpcResp.UserDepartmentMemberList)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}
+
+func DeleteUserInDepartment(c *gin.Context) {
+	params := api.DeleteUserInDepartmentReq{}
+	if err := c.BindJSON(&params); err != nil {
+		log.NewError("0", "BindJSON failed ", err.Error())
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &rpc.DeleteUserInDepartmentReq{}
+	utils.CopyStructFields(req, &params)
+
+	err, opUserID := token_verify.ParseTokenGetUserID(c.Request.Header.Get("token"), req.OperationID)
+	req.OpUserID = opUserID
+	if err != nil {
+		errMsg := "ParseTokenGetUserID failed " + err.Error() + c.Request.Header.Get("token")
+		log.NewError(req.OperationID, errMsg, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api args ", req.String(), "params", params)
+	etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOrganizationName)
+	client := rpc.NewOrganizationClient(etcdConn)
+	RpcResp, err := client.DeleteUserInDepartment(context.Background(), req)
+	if err != nil {
+		errMsg := "rpc DeleteUserInDepartment failed " + err.Error() + req.String()
+		log.NewError(req.OperationID, errMsg)
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": errMsg})
+		return
+	}
+
+	apiResp := api.DeleteUserInDepartmentResp{CommResp: api.CommResp{ErrCode: RpcResp.ErrCode, ErrMsg: RpcResp.ErrMsg}}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "api return ", apiResp)
+	c.JSON(http.StatusOK, apiResp)
+}

internal/api/user/user.go

@@ -4,9 +4,11 @@ import (
 	jsonData "Open_IM/internal/utils"
 	api "Open_IM/pkg/base_info"
 	"Open_IM/pkg/common/config"
+	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/log"
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
+	pbRelay "Open_IM/pkg/proto/relay"
 	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 	rpc "Open_IM/pkg/proto/user"
 	"Open_IM/pkg/utils"
@@ -127,3 +129,63 @@ func GetSelfUserInfo(c *gin.Context) {
 	}
 
 }
+
+func GetUsersOnlineStatus(c *gin.Context) {
+	params := api.GetUsersOnlineStatusReq{}
+	if err := c.BindJSON(&params); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"errCode": 400, "errMsg": err.Error()})
+		return
+	}
+	req := &pbRelay.GetUsersOnlineStatusReq{}
+	utils.CopyStructFields(req, &params)
+	var ok bool
+	ok, req.OpUserID = token_verify.GetUserIDFromToken(c.Request.Header.Get("token"), req.OperationID)
+	if !ok {
+		log.NewError(req.OperationID, "GetUserIDFromToken false ", c.Request.Header.Get("token"))
+		c.JSON(http.StatusInternalServerError, gin.H{"errCode": 500, "errMsg": "GetUserIDFromToken failed"})
+		return
+	}
+	log.NewInfo(params.OperationID, "GetUsersOnlineStatus args ", req.String())
+	var wsResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	var respResult []*pbRelay.GetUsersOnlineStatusResp_SuccessResult
+	flag := false
+	grpcCons := getcdv3.GetConn4Unique(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImOnlineMessageRelayName)
+	for _, v := range grpcCons {
+		client := pbRelay.NewOnlineMessageRelayServiceClient(v)
+		reply, err := client.GetUsersOnlineStatus(context.Background(), req)
+		if err != nil {
+			log.NewError(params.OperationID, "GetUsersOnlineStatus rpc  err", req.String(), err.Error())
+			continue
+		} else {
+			if reply.ErrCode == 0 {
+				wsResult = append(wsResult, reply.SuccessResult...)
+			}
+		}
+	}
+	log.NewInfo(params.OperationID, "call GetUsersOnlineStatus rpc server is success", wsResult)
+	//Online data merge of each node
+	for _, v1 := range params.UserIDList {
+		flag = false
+		temp := new(pbRelay.GetUsersOnlineStatusResp_SuccessResult)
+		for _, v2 := range wsResult {
+			if v2.UserID == v1 {
+				flag = true
+				temp.UserID = v1
+				temp.Status = constant.OnlineStatus
+				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, v2.DetailPlatformStatus...)
+			}
+
+		}
+		if !flag {
+			temp.UserID = v1
+			temp.Status = constant.OfflineStatus
+		}
+		respResult = append(respResult, temp)
+	}
+	resp := api.GetUsersOnlineStatusResp{CommResp: api.CommResp{ErrCode: 0, ErrMsg: ""}, SuccessResult: respResult}
+	if len(respResult) == 0 {
+		resp.SuccessResult = []*pbRelay.GetUsersOnlineStatusResp_SuccessResult{}
+	}
+	log.NewInfo(req.OperationID, "GetUsersOnlineStatus api return", resp)
+	c.JSON(http.StatusOK, resp)
+}

internal/msg_gateway/gate/rpc_server.go

@@ -101,7 +101,7 @@ func (r *RPCServer) OnlinePushMsg(_ context.Context, in *pbRelay.OnlinePushMsgRe
 }
 func (r *RPCServer) GetUsersOnlineStatus(_ context.Context, req *pbRelay.GetUsersOnlineStatusReq) (*pbRelay.GetUsersOnlineStatusResp, error) {
 	log.NewInfo(req.OperationID, "rpc GetUsersOnlineStatus arrived server", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
 		log.NewError(req.OperationID, "no permission GetUsersOnlineStatus ", req.OpUserID)
 		return &pbRelay.GetUsersOnlineStatusResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}

internal/rpc/group/group.go

@@ -202,15 +202,19 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
 func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.InviteUserToGroupReq) (*pbGroup.InviteUserToGroupResp, error) {
 	log.NewInfo(req.OperationID, "InviteUserToGroup args ", req.String())
 
-	if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsExistGroupMember(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.NewError(req.OperationID, "no permission InviteUserToGroup ", req.GroupID, req.OpUserID)
 		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
 	}
 
-	_, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
 	if err != nil {
 		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
-		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, nil
+		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.InviteUserToGroupResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}, nil
 	}
 	//
 	//from User:  invite: applicant
@@ -331,7 +335,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 
 	//op is app manager
 	if flag != 1 {
-		if token_verify.IsMangerUserID(req.OpUserID) {
+		if token_verify.IsManagerUserID(req.OpUserID) {
 			flag = 1
 			log.NewDebug(req.OperationID, "is app manager ", req.OpUserID)
 		}
@@ -467,8 +471,8 @@ func (s *groupServer) GroupApplicationResponse(_ context.Context, req *pbGroup.G
 	groupRequest.UserID = req.FromUserID
 	groupRequest.HandleUserID = req.OpUserID
 	groupRequest.HandledTime = time.Now()
-	if !token_verify.IsMangerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID IsGroupOwnerAdmin false ", req.GroupID, req.OpUserID)
+		log.NewError(req.OperationID, "IsManagerUserID IsGroupOwnerAdmin false ", req.GroupID, req.OpUserID)
 		return &pbGroup.GroupApplicationResponseResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	err := imdb.UpdateGroupRequest(groupRequest)
@@ -518,6 +522,16 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
 	}
 
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
+		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.JoinGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	var groupRequest db.GroupRequest
 	groupRequest.UserID = req.OpUserID
 	groupRequest.ReqMsg = req.ReqMessage
@@ -595,6 +609,11 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, http.WrapError(constant.ErrDB)
 	}
 
+	if group.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	////bitwise operators: 0001:groupName; 0010:Notification  0100:Introduction; 1000:FaceUrl; 10000:owner
 	var changedType int32
 	if group.GroupName != req.GroupInfo.GroupName && req.GroupInfo.GroupName != "" {
@@ -627,12 +646,22 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.TransferGroupOwnerReq) (*pbGroup.TransferGroupOwnerResp, error) {
 	log.NewInfo(req.OperationID, "TransferGroupOwner ", req.String())
 
+	groupInfo, err := imdb.GetGroupInfoByGroupID(req.GroupID)
+	if err != nil {
+		log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", req.GroupID, err)
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	if groupInfo.Status == constant.GroupStatusDismissed {
+		errMsg := " group status is dismissed "
+		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrStatus.ErrCode, ErrMsg: errMsg}}, nil
+	}
+
 	if req.OldOwnerUserID == req.NewOwnerUserID {
 		log.NewError(req.OperationID, "same owner ", req.OldOwnerUserID, req.NewOwnerUserID)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrArgs.ErrCode, ErrMsg: constant.ErrArgs.ErrMsg}}, nil
 	}
 	groupMemberInfo := db.GroupMember{GroupID: req.GroupID, UserID: req.OldOwnerUserID, RoleLevel: constant.GroupOrdinaryUsers}
-	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	err = imdb.UpdateGroupMemberInfo(groupMemberInfo)
 	if err != nil {
 		log.NewError(req.OperationID, "UpdateGroupMemberInfo failed ", groupMemberInfo)
 		return &pbGroup.TransferGroupOwnerResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
@@ -948,7 +977,7 @@ func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.
 
 func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGroupReq) (*pbGroup.DismissGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) {
 		log.NewError(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.DismissGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -977,7 +1006,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 
 func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGroupMemberReq) (*pbGroup.MuteGroupMemberResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.GroupID, req.UserID)
 		return &pbGroup.MuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -996,7 +1025,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 
 func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.CancelMuteGroupMemberReq) (*pbGroup.CancelMuteGroupMemberResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.CancelMuteGroupMemberResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1014,7 +1043,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 
 func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq) (*pbGroup.MuteGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.GroupID, req.GroupID)
 		return &pbGroup.MuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1030,7 +1059,7 @@ func (s *groupServer) MuteGroup(ctx context.Context, req *pbGroup.MuteGroupReq)
 
 func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMuteGroupReq) (*pbGroup.CancelMuteGroupResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
-	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsMangerUserID(req.OpUserID) {
+	if !imdb.IsGroupOwnerAdmin(req.GroupID, req.OpUserID) && !token_verify.IsManagerUserID(req.OpUserID) {
 		log.Error(req.OperationID, "verify failed ", req.OpUserID, req.GroupID)
 		return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
@@ -1044,3 +1073,36 @@ func (s *groupServer) CancelMuteGroup(ctx context.Context, req *pbGroup.CancelMu
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
 	return &pbGroup.CancelMuteGroupResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
 }
+
+func (s *groupServer) SetGroupMemberNickname(ctx context.Context, req *pbGroup.SetGroupMemberNicknameReq) (*pbGroup.SetGroupMemberNicknameResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc args ", req.String())
+	if req.OpUserID != req.UserID && !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " verify failed " + req.OpUserID + req.GroupID
+		log.Error(req.OperationID, errMsg)
+		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
+	}
+
+	groupMemberInfo := db.GroupMember{}
+	groupMemberInfo.UserID = req.UserID
+	groupMemberInfo.GroupID = req.GroupID
+	if req.Nickname == "" {
+		userNickname, err := imdb.GetUserNameByUserID(groupMemberInfo.UserID)
+		if err != nil {
+			errMsg := req.OperationID + " GetUserNameByUserID failed " + err.Error()
+			log.Error(req.OperationID, errMsg)
+			return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+		}
+		groupMemberInfo.Nickname = userNickname
+	} else {
+		groupMemberInfo.Nickname = req.Nickname
+	}
+	err := imdb.UpdateGroupMemberInfo(groupMemberInfo)
+	if err != nil {
+		errMsg := req.OperationID + " UpdateGroupMemberInfo failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil
+	}
+	chat.GroupMemberInfoSetNotification(req.OperationID, req.OpUserID, req.GroupID, req.UserID)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "rpc return ", pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""})
+	return &pbGroup.SetGroupMemberNicknameResp{CommonResp: &pbGroup.CommonResp{ErrCode: 0, ErrMsg: ""}}, nil
+}

internal/rpc/msg/group_notification.go

@@ -22,7 +22,7 @@ import (
 //} creator->group
 
 func setOpUserInfo(opUserID, groupID string, groupMemberInfo *open_im_sdk.GroupMemberFullInfo) error {
-	if token_verify.IsMangerUserID(opUserID) {
+	if token_verify.IsManagerUserID(opUserID) {
 		u, err := imdb.GetUserByUserID(opUserID)
 		if err != nil {
 			return utils.Wrap(err, "GetUserByUserID failed")
@@ -168,6 +168,9 @@ func groupNotification(contentType int32, m proto.Message, sendID, groupID, recv
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberMuted.DefaultTips.Tips
 	case constant.GroupMemberCancelMutedNotification:
 		tips.DefaultTips = toNickname + "" + cn.GroupMemberCancelMuted.DefaultTips.Tips
+	case constant.GroupMemberInfoSetNotification:
+		tips.DefaultTips = toNickname + "" + cn.GroupMemberInfoSet.DefaultTips.Tips
+
 	default:
 		log.Error(operationID, "contentType failed ", contentType)
 		return
@@ -282,6 +285,24 @@ func GroupMemberMutedNotification(operationID, opUserID, groupID, groupMemberUse
 	groupNotification(constant.GroupMemberMutedNotification, &tips, opUserID, groupID, "", operationID)
 }
 
+func GroupMemberInfoSetNotification(operationID, opUserID, groupID, groupMemberUserID string) {
+	tips := open_im_sdk.GroupMemberInfoSetTips{Group: &open_im_sdk.GroupInfo{},
+		OpUser: &open_im_sdk.GroupMemberFullInfo{}, ChangedUser: &open_im_sdk.GroupMemberFullInfo{}}
+	if err := setGroupInfo(groupID, tips.Group); err != nil {
+		log.Error(operationID, "setGroupInfo failed ", err.Error(), groupID)
+		return
+	}
+	if err := setOpUserInfo(opUserID, groupID, tips.OpUser); err != nil {
+		log.Error(operationID, "setOpUserInfo failed ", err.Error(), opUserID, groupID)
+		return
+	}
+	if err := setGroupMemberInfo(groupID, groupMemberUserID, tips.ChangedUser); err != nil {
+		log.Error(operationID, "setGroupMemberInfo failed ", err.Error(), groupID, groupMemberUserID)
+		return
+	}
+	groupNotification(constant.GroupMemberInfoSetNotification, &tips, opUserID, groupID, "", operationID)
+}
+
 func GroupMemberCancelMutedNotification(operationID, opUserID, groupID, groupMemberUserID string) {
 	tips := open_im_sdk.GroupMemberCancelMutedTips{Group: &open_im_sdk.GroupInfo{},
 		OpUser: &open_im_sdk.GroupMemberFullInfo{}, MutedUser: &open_im_sdk.GroupMemberFullInfo{}}

internal/rpc/organization/organization.go

@@ -3,10 +3,15 @@ package organization
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db"
+	imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model"
 	"Open_IM/pkg/common/log"
+	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/grpc-etcdv3/getcdv3"
 	rpc "Open_IM/pkg/proto/organization"
+	open_im_sdk "Open_IM/pkg/proto/sdk_ws"
 	"Open_IM/pkg/utils"
+	"time"
 
 	"context"
 	"google.golang.org/grpc"
@@ -22,11 +27,11 @@ type organizationServer struct {
 	etcdAddr        []string
 }
 
-func NewGroupServer(port int) *organizationServer {
+func NewServer(port int) *organizationServer {
 	log.NewPrivateLog(constant.LogFileName)
 	return &organizationServer{
 		rpcPort:         port,
-		rpcRegisterName: config.Config.RpcRegisterName.OpenImGroupName,
+		rpcRegisterName: config.Config.RpcRegisterName.OpenImOrganizationName,
 		etcdSchema:      config.Config.Etcd.EtcdSchema,
 		etcdAddr:        config.Config.Etcd.EtcdAddr,
 	}
@@ -64,5 +69,305 @@ func (s *organizationServer) Run() {
 }
 
 func (s *organizationServer) CreateDepartment(ctx context.Context, req *rpc.CreateDepartmentReq) (*rpc.CreateDepartmentResp, error) {
-	return nil, nil
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	department := db.Department{}
+	utils.CopyStructFields(&department, req.DepartmentInfo)
+	if department.DepartmentID == "" {
+		department.DepartmentID = utils.Md5(strconv.FormatInt(time.Now().UnixNano(), 10))
+	}
+	log.Debug(req.OperationID, "dst ", department, "src ", req.DepartmentInfo)
+	if err := imdb.CreateDepartment(&department); err != nil {
+		errMsg := req.OperationID + " " + "CreateDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	err, createdDepartment := imdb.GetDepartment(department.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetDepartment failed " + err.Error() + department.DepartmentID
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetDepartment ", department.DepartmentID, *createdDepartment)
+	resp := &rpc.CreateDepartmentResp{DepartmentInfo: &open_im_sdk.Department{}}
+	utils.CopyStructFields(resp.DepartmentInfo, createdDepartment)
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) UpdateDepartment(ctx context.Context, req *rpc.UpdateDepartmentReq) (*rpc.UpdateDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	department := db.Department{}
+	utils.CopyStructFields(&department, req.DepartmentInfo)
+
+	log.Debug(req.OperationID, "dst ", department, "src ", req.DepartmentInfo)
+	if err := imdb.UpdateDepartment(&department, nil); err != nil {
+		errMsg := req.OperationID + " " + "UpdateDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	resp := &rpc.UpdateDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetSubDepartment(ctx context.Context, req *rpc.GetSubDepartmentReq) (*rpc.GetSubDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	err, departmentList := imdb.GetSubDepartmentList(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg)
+		return &rpc.GetSubDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetSubDepartmentList ", req.DepartmentID, departmentList)
+	resp := &rpc.GetSubDepartmentResp{}
+	for _, v := range departmentList {
+		v1 := open_im_sdk.Department{}
+		utils.CopyStructFields(&v1, v)
+		log.Debug(req.OperationID, "src ", v, "dst ", v1)
+		resp.DepartmentList = append(resp.DepartmentList, &v1)
+	}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteDepartment(ctx context.Context, req *rpc.DeleteDepartmentReq) (*rpc.DeleteDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+	err := imdb.DeleteDepartment(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.DepartmentID)
+		return &rpc.DeleteDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteDepartment ", req.DepartmentID)
+	resp := &rpc.DeleteDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return resp, nil
+}
+
+func (s *organizationServer) CreateOrganizationUser(ctx context.Context, req *rpc.CreateOrganizationUserReq) (*rpc.CreateOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	utils.CopyStructFields(&organizationUser, req.OrganizationUser)
+	organizationUser.Birth = utils.UnixSecondToTime(int64(req.OrganizationUser.Birth))
+	log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
+	err := imdb.CreateOrganizationUser(&organizationUser)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, organizationUser)
+		return &rpc.CreateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "CreateOrganizationUser ", organizationUser)
+	resp := &rpc.CreateOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) UpdateOrganizationUser(ctx context.Context, req *rpc.UpdateOrganizationUserReq) (*rpc.UpdateOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	utils.CopyStructFields(&organizationUser, req.OrganizationUser)
+	if req.OrganizationUser.Birth != 0 {
+		organizationUser.Birth = utils.UnixSecondToTime(int64(req.OrganizationUser.Birth))
+		log.Debug(req.OperationID, "time: ", organizationUser.Birth, req.OrganizationUser.Birth)
+	}
+
+	log.Debug(req.OperationID, "src ", *req.OrganizationUser, "dst ", organizationUser)
+	err := imdb.UpdateOrganizationUser(&organizationUser, nil)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, organizationUser)
+		return &rpc.UpdateOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "UpdateOrganizationUser ", organizationUser)
+	resp := &rpc.UpdateOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return resp, nil
+}
+
+func (s *organizationServer) CreateDepartmentMember(ctx context.Context, req *rpc.CreateDepartmentMemberReq) (*rpc.CreateDepartmentMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	err, _ := imdb.GetOrganizationUser(req.DepartmentMember.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + req.DepartmentMember.UserID + " is not exist"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.CreateDepartmentMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	departmentMember := db.DepartmentMember{}
+	utils.CopyStructFields(&departmentMember, req.DepartmentMember)
+	log.Debug(req.OperationID, "src ", *req.DepartmentMember, "dst ", departmentMember)
+	err = imdb.CreateDepartmentMember(&departmentMember)
+	if err != nil {
+		errMsg := req.OperationID + " " + "CreateDepartmentMember failed " + err.Error()
+		log.Error(req.OperationID, errMsg, departmentMember)
+		return &rpc.CreateDepartmentMemberResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "UpdateOrganizationUser ", departmentMember)
+
+	resp := &rpc.CreateDepartmentMemberResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetUserInDepartmentByUserID(userID string, operationID string) (*open_im_sdk.UserInDepartment, error) {
+	err, organizationUser := imdb.GetOrganizationUser(userID)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetOrganizationUser failed")
+	}
+	err, departmentMemberList := imdb.GetUserInDepartment(userID)
+	if err != nil {
+		return nil, utils.Wrap(err, "GetUserInDepartment failed")
+	}
+	log.Debug(operationID, "GetUserInDepartment  ", departmentMemberList)
+	resp := &open_im_sdk.UserInDepartment{OrganizationUser: &open_im_sdk.OrganizationUser{}}
+	utils.CopyStructFields(resp.OrganizationUser, organizationUser)
+	for _, v := range departmentMemberList {
+		v1 := open_im_sdk.DepartmentMember{}
+		utils.CopyStructFields(&v1, v)
+		log.Debug(operationID, "DepartmentMember src  ", v, "dst ", v1)
+		resp.DepartmentMemberList = append(resp.DepartmentMemberList, &v1)
+	}
+	return resp, nil
+}
+
+func (s *organizationServer) GetUserInDepartment(ctx context.Context, req *rpc.GetUserInDepartmentReq) (*rpc.GetUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	r, err := s.GetUserInDepartmentByUserID(req.UserID, req.OperationID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "GetUserInDepartmentByUserID failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.UserID)
+		return &rpc.GetUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "GetUserInDepartmentByUserID success ", req.UserID, r)
+	resp := rpc.GetUserInDepartmentResp{UserInDepartment: &open_im_sdk.UserInDepartment{OrganizationUser: &open_im_sdk.OrganizationUser{}}}
+	resp.UserInDepartment.DepartmentMemberList = r.DepartmentMemberList
+	resp.UserInDepartment.OrganizationUser = r.OrganizationUser
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return &resp, nil
+}
+
+func (s *organizationServer) UpdateUserInDepartment(ctx context.Context, req *rpc.UpdateUserInDepartmentReq) (*rpc.UpdateUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.UpdateUserInDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+	departmentMember := &db.DepartmentMember{}
+	utils.CopyStructFields(departmentMember, req.DepartmentMember)
+	log.Debug(req.OperationID, "dst ", departmentMember, "src ", req.DepartmentMember)
+	err := imdb.UpdateUserInDepartment(departmentMember, nil)
+	if err != nil {
+		errMsg := req.OperationID + " " + "UpdateUserInDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, *departmentMember)
+		return &rpc.UpdateUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	resp := &rpc.UpdateUserInDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteUserInDepartment(ctx context.Context, req *rpc.DeleteUserInDepartmentReq) (*rpc.DeleteUserInDepartmentResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteUserInDepartmentResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	err := imdb.DeleteUserInDepartment(req.DepartmentID, req.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteUserInDepartment failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.DepartmentID, req.UserID)
+		return &rpc.DeleteUserInDepartmentResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteUserInDepartment success ", req.DepartmentID, req.UserID)
+	resp := &rpc.DeleteUserInDepartmentResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) DeleteOrganizationUser(ctx context.Context, req *rpc.DeleteOrganizationUserReq) (*rpc.DeleteOrganizationUserResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	if !token_verify.IsManagerUserID(req.OpUserID) {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.DeleteOrganizationUserResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+	err := imdb.DeleteOrganizationUser(req.UserID)
+	if err != nil {
+		errMsg := req.OperationID + " " + "DeleteOrganizationUser failed " + err.Error()
+		log.Error(req.OperationID, errMsg, req.UserID)
+		return &rpc.DeleteOrganizationUserResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: errMsg}, nil
+	}
+	log.Debug(req.OperationID, "DeleteOrganizationUser success ", req.UserID)
+	resp := &rpc.DeleteOrganizationUserResp{}
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", *resp)
+	return resp, nil
+}
+
+func (s *organizationServer) GetDepartmentMember(ctx context.Context, req *rpc.GetDepartmentMemberReq) (*rpc.GetDepartmentMemberResp, error) {
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc args ", req.String())
+	err, departmentMemberList := imdb.GetDepartmentMemberList(req.DepartmentID)
+	if err != nil {
+		errMsg := req.OperationID + " " + req.OpUserID + " is not app manager"
+		log.Error(req.OperationID, errMsg)
+		return &rpc.GetDepartmentMemberResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: errMsg}, nil
+	}
+
+	log.Debug(req.OperationID, "GetDepartmentMemberList ", departmentMemberList)
+	resp := rpc.GetDepartmentMemberResp{}
+	for _, v := range departmentMemberList {
+		err, organizationUser := imdb.GetOrganizationUser(v.UserID)
+		if err != nil {
+			log.Error(req.OperationID, "GetOrganizationUser failed ", err.Error())
+			continue
+		}
+		respOrganizationUser := &open_im_sdk.OrganizationUser{}
+		respDepartmentMember := &open_im_sdk.DepartmentMember{}
+
+		utils.CopyStructFields(respOrganizationUser, organizationUser)
+		utils.CopyStructFields(respDepartmentMember, &v)
+		userDepartmentMember := open_im_sdk.UserDepartmentMember{OrganizationUser: respOrganizationUser, DepartmentMember: respDepartmentMember}
+
+		log.Debug(req.OperationID, "GetUserInDepartmentByUserID success ", userDepartmentMember)
+		resp.UserDepartmentMemberList = append(resp.UserDepartmentMemberList, &userDepartmentMember)
+	}
+
+	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), " rpc return ", resp)
+	return &resp, nil
 }

internal/rpc/user/user.go

@@ -291,8 +291,8 @@ func (s *userServer) SetRecvMsgOpt(ctx context.Context, req *pbUser.SetRecvMsgOp
 
 func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq) (*pbUser.DeleteUsersResp, error) {
 	log.NewInfo(req.OperationID, "DeleteUsers args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.DeleteUsersResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}, FailedUserIDList: req.DeleteUserIDList}, nil
 	}
 	var common pbUser.CommonResp
@@ -312,8 +312,8 @@ func (s *userServer) DeleteUsers(_ context.Context, req *pbUser.DeleteUsersReq)
 
 func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq) (*pbUser.GetAllUserIDResp, error) {
 	log.NewInfo(req.OperationID, "GetAllUserID args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.GetAllUserIDResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	uidList, err := imdb.SelectAllUserID()
@@ -328,8 +328,8 @@ func (s *userServer) GetAllUserID(_ context.Context, req *pbUser.GetAllUserIDReq
 
 func (s *userServer) AccountCheck(_ context.Context, req *pbUser.AccountCheckReq) (*pbUser.AccountCheckResp, error) {
 	log.NewInfo(req.OperationID, "AccountCheck args ", req.String())
-	if !token_verify.IsMangerUserID(req.OpUserID) {
+	if !token_verify.IsManagerUserID(req.OpUserID) {
-		log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
+		log.NewError(req.OperationID, "IsManagerUserID false ", req.OpUserID)
 		return &pbUser.AccountCheckResp{CommonResp: &pbUser.CommonResp{ErrCode: constant.ErrAccess.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil
 	}
 	uidList, err := imdb.SelectSomeUserID(req.CheckUserIDList)

pkg/base_info/group_api_struct.go

@@ -220,3 +220,14 @@ type CancelMuteGroupReq struct {
 type CancelMuteGroupResp struct {
 	CommResp
 }
+
+type SetGroupMemberNicknameReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	GroupID     string `json:"groupID" binding:"required"`
+	UserID      string `json:"userID" binding:"required"`
+	Nickname    string `json:"nickname"`
+}
+
+type SetGroupMemberNicknameResp struct {
+	CommResp
+}

pkg/base_info/organization_api_struct.go

@@ -0,0 +1,110 @@
+package base_info
+
+import open_im_sdk "Open_IM/pkg/proto/sdk_ws"
+
+type CreateDepartmentReq struct {
+	*open_im_sdk.Department
+	OperationID string `json:"operationID" binding:"required"`
+}
+type CreateDepartmentResp struct {
+	CommResp
+	Department *open_im_sdk.Department `json:"-"`
+	Data       map[string]interface{}  `json:"data"`
+}
+
+type UpdateDepartmentReq struct {
+	*open_im_sdk.Department
+	DepartmentID string `json:"departmentID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type UpdateDepartmentResp struct {
+	CommResp
+}
+
+type GetSubDepartmentReq struct {
+	OperationID  string `json:"operationID" binding:"required"`
+	DepartmentID string `json:"departmentID" binding:"required"`
+}
+type GetSubDepartmentResp struct {
+	CommResp
+	DepartmentList []*open_im_sdk.Department `json:"-"`
+	Data           []map[string]interface{}  `json:"data"`
+}
+
+type DeleteDepartmentReq struct {
+	OperationID  string `json:"operationID" binding:"required"`
+	DepartmentID string `json:"departmentID" binding:"required"`
+}
+type DeleteDepartmentResp struct {
+	CommResp
+}
+
+type CreateOrganizationUserReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.OrganizationUser
+}
+type CreateOrganizationUserResp struct {
+	CommResp
+}
+
+type UpdateOrganizationUserReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.OrganizationUser
+}
+type UpdateOrganizationUserResp struct {
+	CommResp
+}
+
+type CreateDepartmentMemberReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.DepartmentMember
+}
+
+type CreateDepartmentMemberResp struct {
+	CommResp
+}
+
+type GetUserInDepartmentReq struct {
+	UserID      string `json:"userID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+type GetUserInDepartmentResp struct {
+	CommResp
+	UserInDepartment *open_im_sdk.UserInDepartment `json:"-"`
+	Data             map[string]interface{}        `json:"data"`
+}
+
+type UpdateUserInDepartmentReq struct {
+	OperationID string `json:"operationID" binding:"required"`
+	*open_im_sdk.DepartmentMember
+}
+type UpdateUserInDepartmentResp struct {
+	CommResp
+}
+
+type DeleteOrganizationUserReq struct {
+	UserID      string `json:"userID" binding:"required"`
+	OperationID string `json:"operationID" binding:"required"`
+}
+type DeleteOrganizationUserResp struct {
+	CommResp
+}
+
+type GetDepartmentMemberReq struct {
+	DepartmentID string `json:"departmentID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type GetDepartmentMemberResp struct {
+	CommResp
+	UserInDepartmentList []*open_im_sdk.UserDepartmentMember `json:"-"`
+	Data                 []map[string]interface{}            `json:"data"`
+}
+
+type DeleteUserInDepartmentReq struct {
+	DepartmentID string `json:"departmentID" binding:"required"`
+	UserID       string `json:"userID" binding:"required"`
+	OperationID  string `json:"operationID" binding:"required"`
+}
+type DeleteUserInDepartmentResp struct {
+	CommResp
+}

pkg/common/config/config.go

@@ -117,6 +117,7 @@ type config struct {
 		OpenImMessageCMSName         string `yaml:"openImMessageCMSName"`
 		OpenImAdminCMSName           string `yaml:"openImAdminCMSName"`
 		OpenImOfficeName             string `yaml:"openImOfficeName"`
+		OpenImOrganizationName       string `yaml:"openImOrganizationName"`
 	}
 	Etcd struct {
 		EtcdSchema string   `yaml:"etcdSchema"`
@@ -303,6 +304,11 @@ type config struct {
 			OfflinePush  POfflinePush  `yaml:"offlinePush"`
 			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
 		} `yaml:"groupMemberCancelMuted"`
+		GroupMemberInfoSet struct {
+			Conversation PConversation `yaml:"conversation"`
+			OfflinePush  POfflinePush  `yaml:"offlinePush"`
+			DefaultTips  PDefaultTips  `yaml:"defaultTips"`
+		} `yaml:"groupMemberInfoSet"`
 
 		////////////////////////user///////////////////////
 		UserInfoUpdated struct {

pkg/common/constant/constant.go

@@ -81,6 +81,7 @@ const (
 	GroupMemberCancelMutedNotification   = 1513
 	GroupMutedNotification               = 1514
 	GroupCancelMutedNotification         = 1515
+	GroupMemberInfoSetNotification       = 1516
 
 	SignalingNotificationBegin = 1600
 	SignalingNotification      = 1601
@@ -88,8 +89,10 @@ const (
 
 	ConversationPrivateChatNotification = 1701
 
-	WorkMomentNotificationStart      = 1800
+	OrganizationChangedNotification = 1801
-	WorkMomentNewCommentNotification = 1801
+
+	WorkMomentNotificationStart      = 1900
+	WorkMomentNewCommentNotification = 1901
 
 	NotificationEnd = 2000
 

pkg/common/constant/error.go

@@ -51,7 +51,8 @@ var (
 
 	ErrAccess   = ErrInfo{ErrCode: 801, ErrMsg: AccessMsg.Error()}
 	ErrDB       = ErrInfo{ErrCode: 802, ErrMsg: DBMsg.Error()}
-	ErrArgs     = ErrInfo{ErrCode: 8003, ErrMsg: ArgsMsg.Error()}
+	ErrArgs     = ErrInfo{ErrCode: 803, ErrMsg: ArgsMsg.Error()}
+	ErrStatus   = ErrInfo{ErrCode: 804, ErrMsg: StatusMsg.Error()}
 	ErrCallback = ErrInfo{ErrCode: 809, ErrMsg: CallBackMsg.Error()}
 )
 
@@ -64,6 +65,7 @@ var (
 	TokenUnknownMsg     = errors.New("couldn't handle this token")
 	TokenUserKickedMsg  = errors.New("user has been kicked")
 	AccessMsg           = errors.New("no permission")
+	StatusMsg           = errors.New("status is abnormal")
 	DBMsg               = errors.New("db failed")
 	ArgsMsg             = errors.New("args failed")
 	CallBackMsg         = errors.New("callback failed")

pkg/common/db/model_struct.go

@@ -227,9 +227,9 @@ type Department struct {
 	DepartmentID   string    `gorm:"column:department_id;primary_key;size:64" json:"departmentID"`
 	FaceURL        string    `gorm:"column:face_url;size:255" json:"faceURL"`
 	Name           string    `gorm:"column:name;size:256" json:"name" binding:"required"`
-	ParentID       string    `gorm:"column:parent_id;size:64" json:"parentID" binding:"required"`
+	ParentID       string    `gorm:"column:parent_id;size:64" json:"parentID" binding:"required"` // "0" or Real parent id
-	Order          int32     `gorm:"column:order" json:"order" `
+	Order          int32     `gorm:"column:order" json:"order" `                                  // 1, 2, ...
-	DepartmentType int32     `gorm:"column:department_type" json:"departmentType"`
+	DepartmentType int32     `gorm:"column:department_type" json:"departmentType"`                //1, 2...
 	CreateTime     time.Time `gorm:"column:create_time" json:"createTime"`
 	Ex             string    `gorm:"column:ex;type:varchar(1024)" json:"ex"`
 }
@@ -243,7 +243,7 @@ type OrganizationUser struct {
 	Nickname    string    `gorm:"column:nickname;size:256"`
 	EnglishName string    `gorm:"column:english_name;size:256"`
 	FaceURL     string    `gorm:"column:face_url;size:256"`
-	Gender      int32     `gorm:"column:gender"`
+	Gender      int32     `gorm:"column:gender"` //1 ,2
 	Mobile      string    `gorm:"column:mobile;size:32"`
 	Telephone   string    `gorm:"column:telephone;size:32"`
 	Birth       time.Time `gorm:"column:birth"`
@@ -257,13 +257,14 @@ func (OrganizationUser) TableName() string {
 }
 
 type DepartmentMember struct {
-	UserID       string `gorm:"column:user_id;primary_key;size:64"`
+	UserID       string    `gorm:"column:user_id;primary_key;size:64"`
-	DepartmentID string `gorm:"column:department_id;primary_key;size:64"`
+	DepartmentID string    `gorm:"column:department_id;primary_key;size:64"`
-	Order        int32  `gorm:"column:order" json:"order"`
+	Order        int32     `gorm:"column:order" json:"order"` //1,2
-	Position     string `gorm:"column:position;size:256" json:"position"`
+	Position     string    `gorm:"column:position;size:256" json:"position"`
-	Leader       int32  `gorm:"column:leader" json:"leader"`
+	Leader       int32     `gorm:"column:leader" json:"leader"` //-1, 1
-	Status       int32  `gorm:"column:status" json:"status"`
+	Status       int32     `gorm:"column:status" json:"status"` //-1, 1
-	Ex           string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
+	CreateTime   time.Time `gorm:"column:create_time"`
+	Ex           string    `gorm:"column:ex;type:varchar(1024)" json:"ex"`
 }
 
 func (DepartmentMember) TableName() string {

pkg/common/db/mysql.go

@@ -106,20 +106,20 @@ func initMysqlDB() {
 		fmt.Println("CreateTable Conversation")
 		db.CreateTable(&Conversation{})
 	}
-	/*
+
-		if db.HasTable(&Department{}) {
+	if !db.HasTable(&Department{}) {
-			fmt.Println("CreateTable Department")
+		fmt.Println("CreateTable Department")
-			db.CreateTable(&Department{})
+		db.CreateTable(&Department{})
-		}
+	}
-		if db.HasTable(&OrganizationUser{}) {
+	if !db.HasTable(&OrganizationUser{}) {
-			fmt.Println("CreateTable OrganizationUser")
+		fmt.Println("CreateTable OrganizationUser")
-			db.CreateTable(&OrganizationUser{})
+		db.CreateTable(&OrganizationUser{})
-		}
+	}
-		if db.HasTable(&DepartmentMember{}) {
+	if !db.HasTable(&DepartmentMember{}) {
-			fmt.Println("CreateTable DepartmentMember")
+		fmt.Println("CreateTable DepartmentMember")
-			db.CreateTable(&DepartmentMember{})
+		db.CreateTable(&DepartmentMember{})
-		}
+	}
-	*/
+
 	return
 }
 

pkg/common/db/mysql_model/im_mysql_model/organization_model.go

@@ -0,0 +1,189 @@
+package im_mysql_model
+
+import (
+	"Open_IM/pkg/common/db"
+	"time"
+)
+
+func CreateDepartment(department *db.Department) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	department.CreateTime = time.Now()
+	return dbConn.Table("departments").Create(department).Error
+}
+
+func GetDepartment(departmentID string) (error, *db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var department db.Department
+	err = dbConn.Table("departments").Where("department_id=?", departmentID).Find(&department).Error
+	return err, &department
+}
+
+func UpdateDepartment(department *db.Department, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(department).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("departments").Where("department_id=?", department.DepartmentID).Updates(args).Error
+	}
+	return nil
+}
+
+func GetSubDepartmentList(departmentID string) (error, []db.Department) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentList []db.Department
+	err = dbConn.Table("departments").Where("parent_id=?", departmentID).Find(&departmentList).Error
+	return err, departmentList
+}
+
+func DeleteDepartment(departmentID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("departments").Where("department_id=?", departmentID).Delete(db.Department{}).Error; err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=?", departmentID).Delete(db.DepartmentMember{}).Error; err != nil {
+		return err
+	}
+	return nil
+}
+
+func CreateOrganizationUser(organizationUser *db.OrganizationUser) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	organizationUser.CreateTime = time.Now()
+
+	return dbConn.Table("organization_users").Create(organizationUser).Error
+}
+
+func GetOrganizationUser(userID string) (error, *db.OrganizationUser) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	organizationUser := db.OrganizationUser{}
+	err = dbConn.Table("organization_users").Where("user_id=?", userID).Take(&organizationUser).Error
+	return err, &organizationUser
+}
+
+func UpdateOrganizationUser(organizationUser *db.OrganizationUser, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(organizationUser).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("organization_users").Where("user_id=?", organizationUser.UserID).Updates(args).Error
+	}
+	return nil
+}
+
+func CreateDepartmentMember(departmentMember *db.DepartmentMember) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	departmentMember.CreateTime = time.Now()
+	return dbConn.Table("department_members").Create(departmentMember).Error
+}
+
+func GetUserInDepartment(userID string) (error, []db.DepartmentMember) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("user_id=?", userID).Find(&departmentMemberList).Error
+	return err, departmentMemberList
+}
+
+func UpdateUserInDepartment(departmentMember *db.DepartmentMember, args map[string]interface{}) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	if err = dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+		Updates(departmentMember).Error; err != nil {
+		return err
+	}
+	if args != nil {
+		return dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentMember.DepartmentID, departmentMember.UserID).
+			Updates(args).Error
+	}
+	return nil
+}
+
+func DeleteUserInDepartment(departmentID, userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("department_id=? AND user_id=?", departmentID, userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteUserInAllDepartment(userID string) error {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("department_members").Where("user_id=?", userID).Delete(db.DepartmentMember{}).Error
+}
+
+func DeleteOrganizationUser(OrganizationUserID string) error {
+	if err := DeleteUserInAllDepartment(OrganizationUserID); err != nil {
+		return err
+	}
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err
+	}
+	return dbConn.Table("organization_users").Where("user_id=?", OrganizationUserID).Delete(db.OrganizationUser{}).Error
+}
+
+func GetDepartmentMemberUserIDList(departmentID string) (error, []string) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("department_id=?", departmentID).Take(&departmentMemberList).Error
+	if err != nil {
+		return err, nil
+	}
+	var userIDList []string = make([]string, 0)
+	for _, v := range departmentMemberList {
+		userIDList = append(userIDList, v.UserID)
+	}
+	return err, userIDList
+}
+
+func GetDepartmentMemberList(departmentID string) (error, []db.DepartmentMember) {
+	dbConn, err := db.DB.MysqlDB.DefaultGormDB()
+	if err != nil {
+		return err, nil
+	}
+	var departmentMemberList []db.DepartmentMember
+	err = dbConn.Table("department_members").Where("department_id=?", departmentID).Find(&departmentMemberList).Error
+	if err != nil {
+		return err, nil
+	}
+	return err, departmentMemberList
+}

pkg/common/token_verify/jwt_token.go

@@ -111,7 +111,7 @@ func IsAppManagerAccess(token string, OpUserID string) bool {
 	return false
 }
 
-func IsMangerUserID(OpUserID string) bool {
+func IsManagerUserID(OpUserID string) bool {
 	if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
 		return true
 	} else {
@@ -138,21 +138,29 @@ func GetUserIDFromToken(token string, operationID string) (bool, string) {
 	return true, claims.UID
 }
 
+func ParseTokenGetUserID(token string, operationID string) (error, string) {
+	claims, err := ParseToken(token, operationID)
+	if err != nil {
+		return utils.Wrap(err, ""), ""
+	}
+	return nil, claims.UID
+}
+
 func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 	claims, err = GetClaimFromToken(tokensString)
 	if err != nil {
 		log.NewError(operationID, "token validate err", err.Error(), tokensString)
-		return nil, err
+		return nil, utils.Wrap(err, "")
 	}
 
 	m, err := commonDB.DB.GetTokenMapByUidPid(claims.UID, claims.Platform)
 	if err != nil {
 		log.NewError(operationID, "get token from redis err", err.Error(), tokensString)
-		return nil, &constant.ErrTokenInvalid
+		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if m == nil {
 		log.NewError(operationID, "get token from redis err", "m is nil", tokensString)
-		return nil, &constant.ErrTokenInvalid
+		return nil, utils.Wrap(&constant.ErrTokenInvalid, "get token from redis err")
 	}
 	if v, ok := m[tokensString]; ok {
 		switch v {
@@ -160,18 +168,18 @@ func ParseToken(tokensString, operationID string) (claims *Claims, err error) {
 			log.NewDebug(operationID, "this is normal return", claims)
 			return claims, nil
 		case constant.InValidToken:
-			return nil, &constant.ErrTokenInvalid
+			return nil, utils.Wrap(&constant.ErrTokenInvalid, "")
 		case constant.KickedToken:
 			log.Error(operationID, "this token has been kicked by other same terminal ", constant.ErrTokenKicked)
-			return nil, &constant.ErrTokenKicked
+			return nil, utils.Wrap(&constant.ErrTokenKicked, "this token has been kicked by other same terminal ")
 		case constant.ExpiredToken:
-			return nil, &constant.ErrTokenExpired
+			return nil, utils.Wrap(&constant.ErrTokenExpired, "")
 		default:
-			return nil, &constant.ErrTokenUnknown
+			return nil, utils.Wrap(&constant.ErrTokenUnknown, "")
 		}
 	}
 	log.NewError(operationID, "redis token map not find", constant.ErrTokenUnknown)
-	return nil, &constant.ErrTokenUnknown
+	return nil, utils.Wrap(&constant.ErrTokenUnknown, "redis token map not find")
 }
 
 //func MakeTheTokenInvalid(currentClaims *Claims, platformClass string) (bool, error) {

pkg/common/utils/utils.go

@@ -107,7 +107,7 @@ func GroupMemberOpenIMCopyDB(dst *db.GroupMember, src *open_im_sdk.GroupMemberFu
 
 func GroupMemberDBCopyOpenIM(dst *open_im_sdk.GroupMemberFullInfo, src *db.GroupMember) error {
 	utils.CopyStructFields(dst, src)
-	if token_verify.IsMangerUserID(src.UserID) {
+	if token_verify.IsManagerUserID(src.UserID) {
 		u, err := imdb.GetUserByUserID(src.UserID)
 		if err != nil {
 			return utils.Wrap(err, "")

pkg/proto/group/group.pb.go

@@ -36,7 +36,7 @@ func (m *CommonResp) Reset()         { *m = CommonResp{} }
 func (m *CommonResp) String() string { return proto.CompactTextString(m) }
 func (*CommonResp) ProtoMessage()    {}
 func (*CommonResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{0}
+	return fileDescriptor_group_95c16320d90511af, []int{0}
 }
 func (m *CommonResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommonResp.Unmarshal(m, b)
@@ -82,7 +82,7 @@ func (m *GroupAddMemberInfo) Reset()         { *m = GroupAddMemberInfo{} }
 func (m *GroupAddMemberInfo) String() string { return proto.CompactTextString(m) }
 func (*GroupAddMemberInfo) ProtoMessage()    {}
 func (*GroupAddMemberInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{1}
+	return fileDescriptor_group_95c16320d90511af, []int{1}
 }
 func (m *GroupAddMemberInfo) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupAddMemberInfo.Unmarshal(m, b)
@@ -131,7 +131,7 @@ func (m *CreateGroupReq) Reset()         { *m = CreateGroupReq{} }
 func (m *CreateGroupReq) String() string { return proto.CompactTextString(m) }
 func (*CreateGroupReq) ProtoMessage()    {}
 func (*CreateGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{2}
+	return fileDescriptor_group_95c16320d90511af, []int{2}
 }
 func (m *CreateGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateGroupReq.Unmarshal(m, b)
@@ -199,7 +199,7 @@ func (m *CreateGroupResp) Reset()         { *m = CreateGroupResp{} }
 func (m *CreateGroupResp) String() string { return proto.CompactTextString(m) }
 func (*CreateGroupResp) ProtoMessage()    {}
 func (*CreateGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{3}
+	return fileDescriptor_group_95c16320d90511af, []int{3}
 }
 func (m *CreateGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CreateGroupResp.Unmarshal(m, b)
@@ -253,7 +253,7 @@ func (m *GetGroupsInfoReq) Reset()         { *m = GetGroupsInfoReq{} }
 func (m *GetGroupsInfoReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsInfoReq) ProtoMessage()    {}
 func (*GetGroupsInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{4}
+	return fileDescriptor_group_95c16320d90511af, []int{4}
 }
 func (m *GetGroupsInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsInfoReq.Unmarshal(m, b)
@@ -307,7 +307,7 @@ func (m *GetGroupsInfoResp) Reset()         { *m = GetGroupsInfoResp{} }
 func (m *GetGroupsInfoResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsInfoResp) ProtoMessage()    {}
 func (*GetGroupsInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{5}
+	return fileDescriptor_group_95c16320d90511af, []int{5}
 }
 func (m *GetGroupsInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsInfoResp.Unmarshal(m, b)
@@ -361,7 +361,7 @@ func (m *SetGroupInfoReq) Reset()         { *m = SetGroupInfoReq{} }
 func (m *SetGroupInfoReq) String() string { return proto.CompactTextString(m) }
 func (*SetGroupInfoReq) ProtoMessage()    {}
 func (*SetGroupInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{6}
+	return fileDescriptor_group_95c16320d90511af, []int{6}
 }
 func (m *SetGroupInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetGroupInfoReq.Unmarshal(m, b)
@@ -413,7 +413,7 @@ func (m *SetGroupInfoResp) Reset()         { *m = SetGroupInfoResp{} }
 func (m *SetGroupInfoResp) String() string { return proto.CompactTextString(m) }
 func (*SetGroupInfoResp) ProtoMessage()    {}
 func (*SetGroupInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{7}
+	return fileDescriptor_group_95c16320d90511af, []int{7}
 }
 func (m *SetGroupInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SetGroupInfoResp.Unmarshal(m, b)
@@ -453,7 +453,7 @@ func (m *GetGroupApplicationListReq) Reset()         { *m = GetGroupApplicationL
 func (m *GetGroupApplicationListReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupApplicationListReq) ProtoMessage()    {}
 func (*GetGroupApplicationListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{8}
+	return fileDescriptor_group_95c16320d90511af, []int{8}
 }
 func (m *GetGroupApplicationListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupApplicationListReq.Unmarshal(m, b)
@@ -507,7 +507,7 @@ func (m *GetGroupApplicationListResp) Reset()         { *m = GetGroupApplication
 func (m *GetGroupApplicationListResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupApplicationListResp) ProtoMessage()    {}
 func (*GetGroupApplicationListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{9}
+	return fileDescriptor_group_95c16320d90511af, []int{9}
 }
 func (m *GetGroupApplicationListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupApplicationListResp.Unmarshal(m, b)
@@ -561,7 +561,7 @@ func (m *GetUserReqApplicationListReq) Reset()         { *m = GetUserReqApplicat
 func (m *GetUserReqApplicationListReq) String() string { return proto.CompactTextString(m) }
 func (*GetUserReqApplicationListReq) ProtoMessage()    {}
 func (*GetUserReqApplicationListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{10}
+	return fileDescriptor_group_95c16320d90511af, []int{10}
 }
 func (m *GetUserReqApplicationListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserReqApplicationListReq.Unmarshal(m, b)
@@ -614,7 +614,7 @@ func (m *GetUserReqApplicationListResp) Reset()         { *m = GetUserReqApplica
 func (m *GetUserReqApplicationListResp) String() string { return proto.CompactTextString(m) }
 func (*GetUserReqApplicationListResp) ProtoMessage()    {}
 func (*GetUserReqApplicationListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{11}
+	return fileDescriptor_group_95c16320d90511af, []int{11}
 }
 func (m *GetUserReqApplicationListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetUserReqApplicationListResp.Unmarshal(m, b)
@@ -663,7 +663,7 @@ func (m *TransferGroupOwnerReq) Reset()         { *m = TransferGroupOwnerReq{} }
 func (m *TransferGroupOwnerReq) String() string { return proto.CompactTextString(m) }
 func (*TransferGroupOwnerReq) ProtoMessage()    {}
 func (*TransferGroupOwnerReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{12}
+	return fileDescriptor_group_95c16320d90511af, []int{12}
 }
 func (m *TransferGroupOwnerReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TransferGroupOwnerReq.Unmarshal(m, b)
@@ -729,7 +729,7 @@ func (m *TransferGroupOwnerResp) Reset()         { *m = TransferGroupOwnerResp{}
 func (m *TransferGroupOwnerResp) String() string { return proto.CompactTextString(m) }
 func (*TransferGroupOwnerResp) ProtoMessage()    {}
 func (*TransferGroupOwnerResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{13}
+	return fileDescriptor_group_95c16320d90511af, []int{13}
 }
 func (m *TransferGroupOwnerResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TransferGroupOwnerResp.Unmarshal(m, b)
@@ -770,7 +770,7 @@ func (m *JoinGroupReq) Reset()         { *m = JoinGroupReq{} }
 func (m *JoinGroupReq) String() string { return proto.CompactTextString(m) }
 func (*JoinGroupReq) ProtoMessage()    {}
 func (*JoinGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{14}
+	return fileDescriptor_group_95c16320d90511af, []int{14}
 }
 func (m *JoinGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_JoinGroupReq.Unmarshal(m, b)
@@ -829,7 +829,7 @@ func (m *JoinGroupResp) Reset()         { *m = JoinGroupResp{} }
 func (m *JoinGroupResp) String() string { return proto.CompactTextString(m) }
 func (*JoinGroupResp) ProtoMessage()    {}
 func (*JoinGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{15}
+	return fileDescriptor_group_95c16320d90511af, []int{15}
 }
 func (m *JoinGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_JoinGroupResp.Unmarshal(m, b)
@@ -872,7 +872,7 @@ func (m *GroupApplicationResponseReq) Reset()         { *m = GroupApplicationRes
 func (m *GroupApplicationResponseReq) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationResponseReq) ProtoMessage()    {}
 func (*GroupApplicationResponseReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{16}
+	return fileDescriptor_group_95c16320d90511af, []int{16}
 }
 func (m *GroupApplicationResponseReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationResponseReq.Unmarshal(m, b)
@@ -945,7 +945,7 @@ func (m *GroupApplicationResponseResp) Reset()         { *m = GroupApplicationRe
 func (m *GroupApplicationResponseResp) String() string { return proto.CompactTextString(m) }
 func (*GroupApplicationResponseResp) ProtoMessage()    {}
 func (*GroupApplicationResponseResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{17}
+	return fileDescriptor_group_95c16320d90511af, []int{17}
 }
 func (m *GroupApplicationResponseResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GroupApplicationResponseResp.Unmarshal(m, b)
@@ -985,7 +985,7 @@ func (m *QuitGroupReq) Reset()         { *m = QuitGroupReq{} }
 func (m *QuitGroupReq) String() string { return proto.CompactTextString(m) }
 func (*QuitGroupReq) ProtoMessage()    {}
 func (*QuitGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{18}
+	return fileDescriptor_group_95c16320d90511af, []int{18}
 }
 func (m *QuitGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QuitGroupReq.Unmarshal(m, b)
@@ -1037,7 +1037,7 @@ func (m *QuitGroupResp) Reset()         { *m = QuitGroupResp{} }
 func (m *QuitGroupResp) String() string { return proto.CompactTextString(m) }
 func (*QuitGroupResp) ProtoMessage()    {}
 func (*QuitGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{19}
+	return fileDescriptor_group_95c16320d90511af, []int{19}
 }
 func (m *QuitGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_QuitGroupResp.Unmarshal(m, b)
@@ -1079,7 +1079,7 @@ func (m *GetGroupMemberListReq) Reset()         { *m = GetGroupMemberListReq{} }
 func (m *GetGroupMemberListReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberListReq) ProtoMessage()    {}
 func (*GetGroupMemberListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{20}
+	return fileDescriptor_group_95c16320d90511af, []int{20}
 }
 func (m *GetGroupMemberListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberListReq.Unmarshal(m, b)
@@ -1148,7 +1148,7 @@ func (m *GetGroupMemberListResp) Reset()         { *m = GetGroupMemberListResp{}
 func (m *GetGroupMemberListResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberListResp) ProtoMessage()    {}
 func (*GetGroupMemberListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{21}
+	return fileDescriptor_group_95c16320d90511af, []int{21}
 }
 func (m *GetGroupMemberListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberListResp.Unmarshal(m, b)
@@ -1210,7 +1210,7 @@ func (m *GetGroupMembersInfoReq) Reset()         { *m = GetGroupMembersInfoReq{}
 func (m *GetGroupMembersInfoReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersInfoReq) ProtoMessage()    {}
 func (*GetGroupMembersInfoReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{22}
+	return fileDescriptor_group_95c16320d90511af, []int{22}
 }
 func (m *GetGroupMembersInfoReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersInfoReq.Unmarshal(m, b)
@@ -1271,7 +1271,7 @@ func (m *GetGroupMembersInfoResp) Reset()         { *m = GetGroupMembersInfoResp
 func (m *GetGroupMembersInfoResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersInfoResp) ProtoMessage()    {}
 func (*GetGroupMembersInfoResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{23}
+	return fileDescriptor_group_95c16320d90511af, []int{23}
 }
 func (m *GetGroupMembersInfoResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersInfoResp.Unmarshal(m, b)
@@ -1327,7 +1327,7 @@ func (m *KickGroupMemberReq) Reset()         { *m = KickGroupMemberReq{} }
 func (m *KickGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*KickGroupMemberReq) ProtoMessage()    {}
 func (*KickGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{24}
+	return fileDescriptor_group_95c16320d90511af, []int{24}
 }
 func (m *KickGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_KickGroupMemberReq.Unmarshal(m, b)
@@ -1394,7 +1394,7 @@ func (m *Id2Result) Reset()         { *m = Id2Result{} }
 func (m *Id2Result) String() string { return proto.CompactTextString(m) }
 func (*Id2Result) ProtoMessage()    {}
 func (*Id2Result) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{25}
+	return fileDescriptor_group_95c16320d90511af, []int{25}
 }
 func (m *Id2Result) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Id2Result.Unmarshal(m, b)
@@ -1441,7 +1441,7 @@ func (m *KickGroupMemberResp) Reset()         { *m = KickGroupMemberResp{} }
 func (m *KickGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*KickGroupMemberResp) ProtoMessage()    {}
 func (*KickGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{26}
+	return fileDescriptor_group_95c16320d90511af, []int{26}
 }
 func (m *KickGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_KickGroupMemberResp.Unmarshal(m, b)
@@ -1495,7 +1495,7 @@ func (m *GetJoinedGroupListReq) Reset()         { *m = GetJoinedGroupListReq{} }
 func (m *GetJoinedGroupListReq) String() string { return proto.CompactTextString(m) }
 func (*GetJoinedGroupListReq) ProtoMessage()    {}
 func (*GetJoinedGroupListReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{27}
+	return fileDescriptor_group_95c16320d90511af, []int{27}
 }
 func (m *GetJoinedGroupListReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetJoinedGroupListReq.Unmarshal(m, b)
@@ -1549,7 +1549,7 @@ func (m *GetJoinedGroupListResp) Reset()         { *m = GetJoinedGroupListResp{}
 func (m *GetJoinedGroupListResp) String() string { return proto.CompactTextString(m) }
 func (*GetJoinedGroupListResp) ProtoMessage()    {}
 func (*GetJoinedGroupListResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{28}
+	return fileDescriptor_group_95c16320d90511af, []int{28}
 }
 func (m *GetJoinedGroupListResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetJoinedGroupListResp.Unmarshal(m, b)
@@ -1605,7 +1605,7 @@ func (m *InviteUserToGroupReq) Reset()         { *m = InviteUserToGroupReq{} }
 func (m *InviteUserToGroupReq) String() string { return proto.CompactTextString(m) }
 func (*InviteUserToGroupReq) ProtoMessage()    {}
 func (*InviteUserToGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{29}
+	return fileDescriptor_group_95c16320d90511af, []int{29}
 }
 func (m *InviteUserToGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InviteUserToGroupReq.Unmarshal(m, b)
@@ -1673,7 +1673,7 @@ func (m *InviteUserToGroupResp) Reset()         { *m = InviteUserToGroupResp{} }
 func (m *InviteUserToGroupResp) String() string { return proto.CompactTextString(m) }
 func (*InviteUserToGroupResp) ProtoMessage()    {}
 func (*InviteUserToGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{30}
+	return fileDescriptor_group_95c16320d90511af, []int{30}
 }
 func (m *InviteUserToGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_InviteUserToGroupResp.Unmarshal(m, b)
@@ -1727,7 +1727,7 @@ func (m *GetGroupAllMemberReq) Reset()         { *m = GetGroupAllMemberReq{} }
 func (m *GetGroupAllMemberReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupAllMemberReq) ProtoMessage()    {}
 func (*GetGroupAllMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{31}
+	return fileDescriptor_group_95c16320d90511af, []int{31}
 }
 func (m *GetGroupAllMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupAllMemberReq.Unmarshal(m, b)
@@ -1781,7 +1781,7 @@ func (m *GetGroupAllMemberResp) Reset()         { *m = GetGroupAllMemberResp{} }
 func (m *GetGroupAllMemberResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupAllMemberResp) ProtoMessage()    {}
 func (*GetGroupAllMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{32}
+	return fileDescriptor_group_95c16320d90511af, []int{32}
 }
 func (m *GetGroupAllMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupAllMemberResp.Unmarshal(m, b)
@@ -1835,7 +1835,7 @@ func (m *CMSGroup) Reset()         { *m = CMSGroup{} }
 func (m *CMSGroup) String() string { return proto.CompactTextString(m) }
 func (*CMSGroup) ProtoMessage()    {}
 func (*CMSGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{33}
+	return fileDescriptor_group_95c16320d90511af, []int{33}
 }
 func (m *CMSGroup) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CMSGroup.Unmarshal(m, b)
@@ -1889,7 +1889,7 @@ func (m *GetGroupReq) Reset()         { *m = GetGroupReq{} }
 func (m *GetGroupReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupReq) ProtoMessage()    {}
 func (*GetGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{34}
+	return fileDescriptor_group_95c16320d90511af, []int{34}
 }
 func (m *GetGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupReq.Unmarshal(m, b)
@@ -1943,7 +1943,7 @@ func (m *GetGroupResp) Reset()         { *m = GetGroupResp{} }
 func (m *GetGroupResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupResp) ProtoMessage()    {}
 func (*GetGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{35}
+	return fileDescriptor_group_95c16320d90511af, []int{35}
 }
 func (m *GetGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupResp.Unmarshal(m, b)
@@ -1996,7 +1996,7 @@ func (m *GetGroupsReq) Reset()         { *m = GetGroupsReq{} }
 func (m *GetGroupsReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsReq) ProtoMessage()    {}
 func (*GetGroupsReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{36}
+	return fileDescriptor_group_95c16320d90511af, []int{36}
 }
 func (m *GetGroupsReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsReq.Unmarshal(m, b)
@@ -2043,7 +2043,7 @@ func (m *GetGroupsResp) Reset()         { *m = GetGroupsResp{} }
 func (m *GetGroupsResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupsResp) ProtoMessage()    {}
 func (*GetGroupsResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{37}
+	return fileDescriptor_group_95c16320d90511af, []int{37}
 }
 func (m *GetGroupsResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupsResp.Unmarshal(m, b)
@@ -2096,7 +2096,7 @@ func (m *GetGroupMemberReq) Reset()         { *m = GetGroupMemberReq{} }
 func (m *GetGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMemberReq) ProtoMessage()    {}
 func (*GetGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{38}
+	return fileDescriptor_group_95c16320d90511af, []int{38}
 }
 func (m *GetGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMemberReq.Unmarshal(m, b)
@@ -2143,7 +2143,7 @@ func (m *OperateGroupStatusReq) Reset()         { *m = OperateGroupStatusReq{} }
 func (m *OperateGroupStatusReq) String() string { return proto.CompactTextString(m) }
 func (*OperateGroupStatusReq) ProtoMessage()    {}
 func (*OperateGroupStatusReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{39}
+	return fileDescriptor_group_95c16320d90511af, []int{39}
 }
 func (m *OperateGroupStatusReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateGroupStatusReq.Unmarshal(m, b)
@@ -2194,7 +2194,7 @@ func (m *OperateGroupStatusResp) Reset()         { *m = OperateGroupStatusResp{}
 func (m *OperateGroupStatusResp) String() string { return proto.CompactTextString(m) }
 func (*OperateGroupStatusResp) ProtoMessage()    {}
 func (*OperateGroupStatusResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{40}
+	return fileDescriptor_group_95c16320d90511af, []int{40}
 }
 func (m *OperateGroupStatusResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateGroupStatusResp.Unmarshal(m, b)
@@ -2228,7 +2228,7 @@ func (m *OperateUserRoleReq) Reset()         { *m = OperateUserRoleReq{} }
 func (m *OperateUserRoleReq) String() string { return proto.CompactTextString(m) }
 func (*OperateUserRoleReq) ProtoMessage()    {}
 func (*OperateUserRoleReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{41}
+	return fileDescriptor_group_95c16320d90511af, []int{41}
 }
 func (m *OperateUserRoleReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateUserRoleReq.Unmarshal(m, b)
@@ -2286,7 +2286,7 @@ func (m *OperateUserRoleResp) Reset()         { *m = OperateUserRoleResp{} }
 func (m *OperateUserRoleResp) String() string { return proto.CompactTextString(m) }
 func (*OperateUserRoleResp) ProtoMessage()    {}
 func (*OperateUserRoleResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{42}
+	return fileDescriptor_group_95c16320d90511af, []int{42}
 }
 func (m *OperateUserRoleResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperateUserRoleResp.Unmarshal(m, b)
@@ -2318,7 +2318,7 @@ func (m *DeleteGroupReq) Reset()         { *m = DeleteGroupReq{} }
 func (m *DeleteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*DeleteGroupReq) ProtoMessage()    {}
 func (*DeleteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{43}
+	return fileDescriptor_group_95c16320d90511af, []int{43}
 }
 func (m *DeleteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteGroupReq.Unmarshal(m, b)
@@ -2362,7 +2362,7 @@ func (m *DeleteGroupResp) Reset()         { *m = DeleteGroupResp{} }
 func (m *DeleteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*DeleteGroupResp) ProtoMessage()    {}
 func (*DeleteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{44}
+	return fileDescriptor_group_95c16320d90511af, []int{44}
 }
 func (m *DeleteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DeleteGroupResp.Unmarshal(m, b)
@@ -2394,7 +2394,7 @@ func (m *GetGroupByIdReq) Reset()         { *m = GetGroupByIdReq{} }
 func (m *GetGroupByIdReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupByIdReq) ProtoMessage()    {}
 func (*GetGroupByIdReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{45}
+	return fileDescriptor_group_95c16320d90511af, []int{45}
 }
 func (m *GetGroupByIdReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupByIdReq.Unmarshal(m, b)
@@ -2439,7 +2439,7 @@ func (m *GetGroupByIdResp) Reset()         { *m = GetGroupByIdResp{} }
 func (m *GetGroupByIdResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupByIdResp) ProtoMessage()    {}
 func (*GetGroupByIdResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{46}
+	return fileDescriptor_group_95c16320d90511af, []int{46}
 }
 func (m *GetGroupByIdResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupByIdResp.Unmarshal(m, b)
@@ -2480,7 +2480,7 @@ func (m *GetGroupMembersCMSReq) Reset()         { *m = GetGroupMembersCMSReq{} }
 func (m *GetGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersCMSReq) ProtoMessage()    {}
 func (*GetGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{47}
+	return fileDescriptor_group_95c16320d90511af, []int{47}
 }
 func (m *GetGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersCMSReq.Unmarshal(m, b)
@@ -2541,7 +2541,7 @@ func (m *GetGroupMembersCMSResp) Reset()         { *m = GetGroupMembersCMSResp{}
 func (m *GetGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*GetGroupMembersCMSResp) ProtoMessage()    {}
 func (*GetGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{48}
+	return fileDescriptor_group_95c16320d90511af, []int{48}
 }
 func (m *GetGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetGroupMembersCMSResp.Unmarshal(m, b)
@@ -2596,7 +2596,7 @@ func (m *RemoveGroupMembersCMSReq) Reset()         { *m = RemoveGroupMembersCMSR
 func (m *RemoveGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*RemoveGroupMembersCMSReq) ProtoMessage()    {}
 func (*RemoveGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{49}
+	return fileDescriptor_group_95c16320d90511af, []int{49}
 }
 func (m *RemoveGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveGroupMembersCMSReq.Unmarshal(m, b)
@@ -2656,7 +2656,7 @@ func (m *RemoveGroupMembersCMSResp) Reset()         { *m = RemoveGroupMembersCMS
 func (m *RemoveGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*RemoveGroupMembersCMSResp) ProtoMessage()    {}
 func (*RemoveGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{50}
+	return fileDescriptor_group_95c16320d90511af, []int{50}
 }
 func (m *RemoveGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RemoveGroupMembersCMSResp.Unmarshal(m, b)
@@ -2704,7 +2704,7 @@ func (m *AddGroupMembersCMSReq) Reset()         { *m = AddGroupMembersCMSReq{} }
 func (m *AddGroupMembersCMSReq) String() string { return proto.CompactTextString(m) }
 func (*AddGroupMembersCMSReq) ProtoMessage()    {}
 func (*AddGroupMembersCMSReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{51}
+	return fileDescriptor_group_95c16320d90511af, []int{51}
 }
 func (m *AddGroupMembersCMSReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddGroupMembersCMSReq.Unmarshal(m, b)
@@ -2764,7 +2764,7 @@ func (m *AddGroupMembersCMSResp) Reset()         { *m = AddGroupMembersCMSResp{}
 func (m *AddGroupMembersCMSResp) String() string { return proto.CompactTextString(m) }
 func (*AddGroupMembersCMSResp) ProtoMessage()    {}
 func (*AddGroupMembersCMSResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{52}
+	return fileDescriptor_group_95c16320d90511af, []int{52}
 }
 func (m *AddGroupMembersCMSResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_AddGroupMembersCMSResp.Unmarshal(m, b)
@@ -2811,7 +2811,7 @@ func (m *DismissGroupReq) Reset()         { *m = DismissGroupReq{} }
 func (m *DismissGroupReq) String() string { return proto.CompactTextString(m) }
 func (*DismissGroupReq) ProtoMessage()    {}
 func (*DismissGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{53}
+	return fileDescriptor_group_95c16320d90511af, []int{53}
 }
 func (m *DismissGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DismissGroupReq.Unmarshal(m, b)
@@ -2863,7 +2863,7 @@ func (m *DismissGroupResp) Reset()         { *m = DismissGroupResp{} }
 func (m *DismissGroupResp) String() string { return proto.CompactTextString(m) }
 func (*DismissGroupResp) ProtoMessage()    {}
 func (*DismissGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{54}
+	return fileDescriptor_group_95c16320d90511af, []int{54}
 }
 func (m *DismissGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_DismissGroupResp.Unmarshal(m, b)
@@ -2905,7 +2905,7 @@ func (m *MuteGroupMemberReq) Reset()         { *m = MuteGroupMemberReq{} }
 func (m *MuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupMemberReq) ProtoMessage()    {}
 func (*MuteGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{55}
+	return fileDescriptor_group_95c16320d90511af, []int{55}
 }
 func (m *MuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupMemberReq.Unmarshal(m, b)
@@ -2971,7 +2971,7 @@ func (m *MuteGroupMemberResp) Reset()         { *m = MuteGroupMemberResp{} }
 func (m *MuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupMemberResp) ProtoMessage()    {}
 func (*MuteGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{56}
+	return fileDescriptor_group_95c16320d90511af, []int{56}
 }
 func (m *MuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupMemberResp.Unmarshal(m, b)
@@ -3012,7 +3012,7 @@ func (m *CancelMuteGroupMemberReq) Reset()         { *m = CancelMuteGroupMemberR
 func (m *CancelMuteGroupMemberReq) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupMemberReq) ProtoMessage()    {}
 func (*CancelMuteGroupMemberReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{57}
+	return fileDescriptor_group_95c16320d90511af, []int{57}
 }
 func (m *CancelMuteGroupMemberReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupMemberReq.Unmarshal(m, b)
@@ -3071,7 +3071,7 @@ func (m *CancelMuteGroupMemberResp) Reset()         { *m = CancelMuteGroupMember
 func (m *CancelMuteGroupMemberResp) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupMemberResp) ProtoMessage()    {}
 func (*CancelMuteGroupMemberResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{58}
+	return fileDescriptor_group_95c16320d90511af, []int{58}
 }
 func (m *CancelMuteGroupMemberResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupMemberResp.Unmarshal(m, b)
@@ -3111,7 +3111,7 @@ func (m *MuteGroupReq) Reset()         { *m = MuteGroupReq{} }
 func (m *MuteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupReq) ProtoMessage()    {}
 func (*MuteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{59}
+	return fileDescriptor_group_95c16320d90511af, []int{59}
 }
 func (m *MuteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupReq.Unmarshal(m, b)
@@ -3163,7 +3163,7 @@ func (m *MuteGroupResp) Reset()         { *m = MuteGroupResp{} }
 func (m *MuteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*MuteGroupResp) ProtoMessage()    {}
 func (*MuteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{60}
+	return fileDescriptor_group_95c16320d90511af, []int{60}
 }
 func (m *MuteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MuteGroupResp.Unmarshal(m, b)
@@ -3203,7 +3203,7 @@ func (m *CancelMuteGroupReq) Reset()         { *m = CancelMuteGroupReq{} }
 func (m *CancelMuteGroupReq) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupReq) ProtoMessage()    {}
 func (*CancelMuteGroupReq) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{61}
+	return fileDescriptor_group_95c16320d90511af, []int{61}
 }
 func (m *CancelMuteGroupReq) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupReq.Unmarshal(m, b)
@@ -3255,7 +3255,7 @@ func (m *CancelMuteGroupResp) Reset()         { *m = CancelMuteGroupResp{} }
 func (m *CancelMuteGroupResp) String() string { return proto.CompactTextString(m) }
 func (*CancelMuteGroupResp) ProtoMessage()    {}
 func (*CancelMuteGroupResp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_group_3c77315b028a1402, []int{62}
+	return fileDescriptor_group_95c16320d90511af, []int{62}
 }
 func (m *CancelMuteGroupResp) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CancelMuteGroupResp.Unmarshal(m, b)
@@ -3282,6 +3282,114 @@ func (m *CancelMuteGroupResp) GetCommonResp() *CommonResp {
 	return nil
 }
 
+type SetGroupMemberNicknameReq struct {
+	GroupID              string   `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"`
+	Nickname             string   `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"`
+	OpUserID             string   `protobuf:"bytes,3,opt,name=opUserID" json:"opUserID,omitempty"`
+	OperationID          string   `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"`
+	UserID               string   `protobuf:"bytes,5,opt,name=userID" json:"userID,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *SetGroupMemberNicknameReq) Reset()         { *m = SetGroupMemberNicknameReq{} }
+func (m *SetGroupMemberNicknameReq) String() string { return proto.CompactTextString(m) }
+func (*SetGroupMemberNicknameReq) ProtoMessage()    {}
+func (*SetGroupMemberNicknameReq) Descriptor() ([]byte, []int) {
+	return fileDescriptor_group_95c16320d90511af, []int{63}
+}
+func (m *SetGroupMemberNicknameReq) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Unmarshal(m, b)
+}
+func (m *SetGroupMemberNicknameReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Marshal(b, m, deterministic)
+}
+func (dst *SetGroupMemberNicknameReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetGroupMemberNicknameReq.Merge(dst, src)
+}
+func (m *SetGroupMemberNicknameReq) XXX_Size() int {
+	return xxx_messageInfo_SetGroupMemberNicknameReq.Size(m)
+}
+func (m *SetGroupMemberNicknameReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetGroupMemberNicknameReq.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetGroupMemberNicknameReq proto.InternalMessageInfo
+
+func (m *SetGroupMemberNicknameReq) GetGroupID() string {
+	if m != nil {
+		return m.GroupID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetNickname() string {
+	if m != nil {
+		return m.Nickname
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetOpUserID() string {
+	if m != nil {
+		return m.OpUserID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetOperationID() string {
+	if m != nil {
+		return m.OperationID
+	}
+	return ""
+}
+
+func (m *SetGroupMemberNicknameReq) GetUserID() string {
+	if m != nil {
+		return m.UserID
+	}
+	return ""
+}
+
+type SetGroupMemberNicknameResp struct {
+	CommonResp           *CommonResp `protobuf:"bytes,1,opt,name=CommonResp" json:"CommonResp,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *SetGroupMemberNicknameResp) Reset()         { *m = SetGroupMemberNicknameResp{} }
+func (m *SetGroupMemberNicknameResp) String() string { return proto.CompactTextString(m) }
+func (*SetGroupMemberNicknameResp) ProtoMessage()    {}
+func (*SetGroupMemberNicknameResp) Descriptor() ([]byte, []int) {
+	return fileDescriptor_group_95c16320d90511af, []int{64}
+}
+func (m *SetGroupMemberNicknameResp) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Unmarshal(m, b)
+}
+func (m *SetGroupMemberNicknameResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Marshal(b, m, deterministic)
+}
+func (dst *SetGroupMemberNicknameResp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_SetGroupMemberNicknameResp.Merge(dst, src)
+}
+func (m *SetGroupMemberNicknameResp) XXX_Size() int {
+	return xxx_messageInfo_SetGroupMemberNicknameResp.Size(m)
+}
+func (m *SetGroupMemberNicknameResp) XXX_DiscardUnknown() {
+	xxx_messageInfo_SetGroupMemberNicknameResp.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetGroupMemberNicknameResp proto.InternalMessageInfo
+
+func (m *SetGroupMemberNicknameResp) GetCommonResp() *CommonResp {
+	if m != nil {
+		return m.CommonResp
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*CommonResp)(nil), "group.CommonResp")
 	proto.RegisterType((*GroupAddMemberInfo)(nil), "group.GroupAddMemberInfo")
@@ -3346,6 +3454,8 @@ func init() {
 	proto.RegisterType((*MuteGroupResp)(nil), "group.MuteGroupResp")
 	proto.RegisterType((*CancelMuteGroupReq)(nil), "group.CancelMuteGroupReq")
 	proto.RegisterType((*CancelMuteGroupResp)(nil), "group.CancelMuteGroupResp")
+	proto.RegisterType((*SetGroupMemberNicknameReq)(nil), "group.SetGroupMemberNicknameReq")
+	proto.RegisterType((*SetGroupMemberNicknameResp)(nil), "group.SetGroupMemberNicknameResp")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3388,6 +3498,7 @@ type GroupClient interface {
 	CancelMuteGroupMember(ctx context.Context, in *CancelMuteGroupMemberReq, opts ...grpc.CallOption) (*CancelMuteGroupMemberResp, error)
 	MuteGroup(ctx context.Context, in *MuteGroupReq, opts ...grpc.CallOption) (*MuteGroupResp, error)
 	CancelMuteGroup(ctx context.Context, in *CancelMuteGroupReq, opts ...grpc.CallOption) (*CancelMuteGroupResp, error)
+	SetGroupMemberNickname(ctx context.Context, in *SetGroupMemberNicknameReq, opts ...grpc.CallOption) (*SetGroupMemberNicknameResp, error)
 }
 
 type groupClient struct {
@@ -3659,6 +3770,15 @@ func (c *groupClient) CancelMuteGroup(ctx context.Context, in *CancelMuteGroupRe
 	return out, nil
 }
 
+func (c *groupClient) SetGroupMemberNickname(ctx context.Context, in *SetGroupMemberNicknameReq, opts ...grpc.CallOption) (*SetGroupMemberNicknameResp, error) {
+	out := new(SetGroupMemberNicknameResp)
+	err := grpc.Invoke(ctx, "/group.group/SetGroupMemberNickname", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for Group service
 
 type GroupServer interface {
@@ -3691,6 +3811,7 @@ type GroupServer interface {
 	CancelMuteGroupMember(context.Context, *CancelMuteGroupMemberReq) (*CancelMuteGroupMemberResp, error)
 	MuteGroup(context.Context, *MuteGroupReq) (*MuteGroupResp, error)
 	CancelMuteGroup(context.Context, *CancelMuteGroupReq) (*CancelMuteGroupResp, error)
+	SetGroupMemberNickname(context.Context, *SetGroupMemberNicknameReq) (*SetGroupMemberNicknameResp, error)
 }
 
 func RegisterGroupServer(s *grpc.Server, srv GroupServer) {
@@ -4219,6 +4340,24 @@ func _Group_CancelMuteGroup_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Group_SetGroupMemberNickname_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SetGroupMemberNicknameReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GroupServer).SetGroupMemberNickname(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/group.group/SetGroupMemberNickname",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GroupServer).SetGroupMemberNickname(ctx, req.(*SetGroupMemberNicknameReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Group_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "group.group",
 	HandlerType: (*GroupServer)(nil),
@@ -4339,143 +4478,151 @@ var _Group_serviceDesc = grpc.ServiceDesc{
 			MethodName: "CancelMuteGroup",
 			Handler:    _Group_CancelMuteGroup_Handler,
 		},
+		{
+			MethodName: "SetGroupMemberNickname",
+			Handler:    _Group_SetGroupMemberNickname_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "group/group.proto",
 }
 
-func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_3c77315b028a1402) }
+func init() { proto.RegisterFile("group/group.proto", fileDescriptor_group_95c16320d90511af) }
 
-var fileDescriptor_group_3c77315b028a1402 = []byte{
+var fileDescriptor_group_95c16320d90511af = []byte{
-	// 2068 bytes of a gzipped FileDescriptorProto
+	// 2138 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4f, 0x6f, 0xdb, 0xc8,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x1a, 0x4d, 0x6f, 0x1c, 0x49,
-	0x15, 0x07, 0xed, 0xc8, 0xb6, 0x9e, 0xad, 0xc8, 0x1e, 0x47, 0xb6, 0xc2, 0xf5, 0x66, 0xbd, 0xb3,
+	0x55, 0xed, 0xf1, 0xd8, 0x9e, 0x67, 0x4f, 0xc6, 0x2e, 0xef, 0xd8, 0xe3, 0x5e, 0x6f, 0xd6, 0xa9,
-	0xe9, 0x22, 0xe8, 0x1f, 0x1b, 0xcd, 0x02, 0x39, 0x74, 0x8b, 0xa6, 0xf1, 0x9f, 0xc4, 0x4a, 0x22,
+	0x0d, 0xab, 0x88, 0x0f, 0x5b, 0x64, 0xa5, 0x1c, 0x58, 0x44, 0x88, 0x3f, 0x12, 0x4f, 0x92, 0xb1,
-	0xbb, 0xa1, 0xd3, 0x4b, 0x2e, 0xa9, 0x56, 0x1c, 0x0b, 0xaa, 0x25, 0x92, 0xe6, 0x50, 0x4e, 0xdb,
+	0x49, 0x3b, 0x5c, 0x22, 0xa1, 0x30, 0x3b, 0x5d, 0x1e, 0x0d, 0x9e, 0xe9, 0x6e, 0x77, 0xf5, 0x38,
-	0xcb, 0xa2, 0x97, 0x05, 0xb6, 0xed, 0xa1, 0x45, 0x81, 0x3d, 0x15, 0x68, 0x73, 0xeb, 0xa1, 0x87,
+	0xc0, 0x65, 0xc5, 0x65, 0xa5, 0x05, 0x0e, 0x20, 0x24, 0x4e, 0x48, 0xb0, 0x27, 0x38, 0x70, 0xe0,
-	0x1e, 0xda, 0x73, 0xd1, 0x8f, 0xd1, 0x4f, 0xd1, 0xaf, 0x50, 0x70, 0x66, 0x38, 0x1c, 0x0e, 0x87,
+	0x00, 0x67, 0xc4, 0xcf, 0xe0, 0x57, 0x70, 0xe2, 0x8e, 0xba, 0xaa, 0xba, 0xba, 0xba, 0xab, 0xba,
-	0xb4, 0x42, 0x25, 0xcd, 0x45, 0xc0, 0xbc, 0x79, 0xc3, 0xf7, 0x7b, 0x6f, 0xe6, 0xbd, 0x79, 0xef,
+	0x3d, 0x99, 0x49, 0xc8, 0x65, 0xa4, 0xf7, 0xea, 0x55, 0xbf, 0x8f, 0x7a, 0xef, 0xd5, 0x7b, 0xaf,
-	0x8d, 0x60, 0x6d, 0x10, 0xfa, 0x93, 0x60, 0x97, 0xfd, 0xee, 0x04, 0xa1, 0x1f, 0xf9, 0xa8, 0xc6,
+	0x06, 0xd6, 0xfa, 0xa1, 0x3f, 0x0e, 0xf6, 0xd8, 0xef, 0x6e, 0x10, 0xfa, 0x91, 0x8f, 0xaa, 0x0c,
-	0x06, 0xf6, 0xc7, 0x27, 0x01, 0xf1, 0x5e, 0x76, 0xba, 0xbb, 0xc1, 0xf9, 0x60, 0x97, 0xcd, 0xec,
+	0xb0, 0x6f, 0x9d, 0x06, 0xc4, 0x7b, 0xd9, 0xee, 0xec, 0x05, 0x17, 0xfd, 0x3d, 0xb6, 0xb2, 0x47,
-	0x52, 0xf7, 0xfc, 0xe5, 0x2b, 0xba, 0xfb, 0x8a, 0x72, 0x4e, 0xfc, 0x23, 0x80, 0x7d, 0x7f, 0x3c,
+	0xdd, 0x8b, 0x97, 0xaf, 0xe8, 0xde, 0x2b, 0xca, 0x29, 0xf1, 0xf7, 0x00, 0x0e, 0xfc, 0xd1, 0xc8,
-	0xf6, 0x3d, 0x87, 0xd0, 0x00, 0xb5, 0x61, 0xf1, 0x30, 0x0c, 0xf7, 0x7d, 0x97, 0xb4, 0xad, 0x6d,
+	0xf7, 0x1c, 0x42, 0x03, 0xd4, 0x82, 0xc5, 0xa3, 0x30, 0x3c, 0xf0, 0x5d, 0xd2, 0xb2, 0x76, 0xac,
-	0xeb, 0x4e, 0xcd, 0x49, 0x86, 0x68, 0x03, 0x16, 0x0e, 0xc3, 0xb0, 0x4b, 0x07, 0xed, 0xb9, 0x6d,
+	0x3b, 0x55, 0x27, 0x01, 0xd1, 0x06, 0x2c, 0x1c, 0x85, 0x61, 0x87, 0xf6, 0x5b, 0x73, 0x3b, 0xd6,
-	0xeb, 0x4e, 0xdd, 0x11, 0x23, 0xfc, 0x18, 0xd0, 0xa3, 0x58, 0xd6, 0x03, 0xd7, 0xed, 0x92, 0xf1,
+	0x9d, 0x9a, 0x23, 0x20, 0xfc, 0x18, 0xd0, 0xa3, 0x98, 0xd7, 0x03, 0xd7, 0xed, 0x90, 0xd1, 0x67,
-	0x17, 0x24, 0xec, 0x78, 0x67, 0x7e, 0xcc, 0xfd, 0x53, 0x4a, 0xc2, 0xce, 0x01, 0xfb, 0x4c, 0xdd,
+	0x24, 0x6c, 0x7b, 0xe7, 0x7e, 0x4c, 0xfd, 0x43, 0x4a, 0xc2, 0xf6, 0x21, 0xfb, 0x4c, 0xcd, 0x11,
-	0x11, 0x23, 0xb4, 0x05, 0x75, 0xc7, 0x1f, 0x91, 0xa7, 0xe4, 0x92, 0x8c, 0xd8, 0x87, 0x6a, 0x4e,
+	0x10, 0xda, 0x86, 0x9a, 0xe3, 0x0f, 0xc9, 0x53, 0x72, 0x45, 0x86, 0xec, 0x43, 0x55, 0x27, 0x45,
-	0x4a, 0xc0, 0xff, 0xb5, 0xe0, 0xfa, 0x7e, 0x48, 0x7a, 0x11, 0x61, 0x9f, 0x74, 0xc8, 0x05, 0x7a,
+	0xe0, 0xff, 0x58, 0x70, 0xe3, 0x20, 0x24, 0xdd, 0x88, 0xb0, 0x4f, 0x3a, 0xe4, 0x12, 0x3d, 0x80,
-	0x00, 0xd7, 0x3b, 0xde, 0x30, 0xe2, 0x9f, 0x7e, 0x3a, 0xa4, 0x51, 0xdb, 0xda, 0x9e, 0xbf, 0xb3,
+	0x1b, 0x6d, 0x6f, 0x10, 0xf1, 0x4f, 0x3f, 0x1d, 0xd0, 0xa8, 0x65, 0xed, 0x54, 0xee, 0x2c, 0xdf,
-	0x7c, 0xf7, 0xe6, 0x0e, 0x57, 0x37, 0x2f, 0xdb, 0xd1, 0x16, 0xa0, 0x1f, 0x40, 0x9d, 0x71, 0xc5,
+	0xdd, 0xda, 0xe5, 0xea, 0xea, 0xbc, 0x9d, 0xdc, 0x06, 0xf4, 0x1d, 0xa8, 0x31, 0xaa, 0x78, 0x91,
-	0x93, 0x4c, 0xe6, 0xf2, 0xdd, 0xad, 0x1d, 0x4a, 0xc2, 0x4b, 0x12, 0xbe, 0xec, 0x05, 0xc3, 0x97,
+	0xf1, 0x5c, 0xbe, 0xbb, 0xbd, 0x4b, 0x49, 0x78, 0x45, 0xc2, 0x97, 0xdd, 0x60, 0xf0, 0x32, 0xe8,
-	0x41, 0x2f, 0xec, 0x8d, 0xe9, 0x8e, 0xe4, 0x71, 0x52, 0x76, 0xb4, 0x0d, 0xcb, 0x27, 0x01, 0x09,
+	0x86, 0xdd, 0x11, 0xdd, 0x95, 0x34, 0x4e, 0x4a, 0x8e, 0x76, 0x60, 0xf9, 0x34, 0x20, 0x61, 0x37,
-	0x7b, 0xd1, 0xd0, 0xf7, 0x3a, 0x07, 0xed, 0x79, 0xa6, 0x8c, 0x4a, 0x42, 0x36, 0x2c, 0x9d, 0x04,
+	0x1a, 0xf8, 0x5e, 0xfb, 0xb0, 0x55, 0x61, 0xca, 0xa8, 0x28, 0x64, 0xc3, 0xd2, 0x69, 0x20, 0x74,
-	0x42, 0xd7, 0x6b, 0x6c, 0x5a, 0x8e, 0xd9, 0xea, 0x57, 0x1e, 0x09, 0xc5, 0x74, 0x4d, 0xac, 0x4e,
+	0x9d, 0x67, 0xcb, 0x12, 0x66, 0xbb, 0x5f, 0x79, 0x24, 0x14, 0xcb, 0x55, 0xb1, 0x3b, 0x45, 0xe1,
-	0x49, 0xf8, 0x4b, 0x68, 0x66, 0x14, 0xae, 0xb2, 0x05, 0x59, 0x05, 0xe7, 0xdf, 0x48, 0x41, 0x1c,
+	0xcf, 0xa1, 0x91, 0x51, 0x78, 0x9a, 0x23, 0xc8, 0x2a, 0x58, 0x79, 0x2d, 0x05, 0x71, 0x08, 0xab,
-	0xc2, 0xea, 0x23, 0x12, 0xb1, 0x31, 0x65, 0x73, 0xe4, 0x22, 0x86, 0xcd, 0x19, 0x0e, 0xa4, 0xc1,
+	0x8f, 0x48, 0xc4, 0x60, 0xca, 0xd6, 0xc8, 0x65, 0x2c, 0x36, 0x27, 0x38, 0x94, 0x06, 0xaf, 0x39,
-	0xeb, 0x8e, 0x4a, 0xd2, 0xcd, 0x32, 0x57, 0x6e, 0x96, 0xf9, 0xac, 0x59, 0xf0, 0xd7, 0x16, 0xac,
+	0x2a, 0x2a, 0x6f, 0x96, 0xb9, 0x72, 0xb3, 0x54, 0xb2, 0x66, 0xc1, 0x5f, 0x5a, 0xb0, 0x96, 0x63,
-	0x69, 0x42, 0x2b, 0xe9, 0xbd, 0x07, 0x0d, 0xa9, 0x08, 0x43, 0x3a, 0xcf, 0x8e, 0x46, 0xb9, 0xee,
+	0x3a, 0x95, 0xde, 0xfb, 0x50, 0x97, 0x8a, 0x30, 0x49, 0x2b, 0xcc, 0x35, 0xca, 0x75, 0xcf, 0x6e,
-	0xd9, 0x25, 0xf8, 0xb7, 0x16, 0x34, 0x4f, 0x05, 0x96, 0x44, 0xff, 0x8c, 0x3d, 0xad, 0x37, 0x3b,
+	0xc1, 0xbf, 0xb2, 0xa0, 0x71, 0x26, 0x64, 0x49, 0xf4, 0xcf, 0xd8, 0xd3, 0x7a, 0x3d, 0x87, 0x51,
-	0x30, 0xaa, 0xde, 0x73, 0x86, 0xe3, 0x50, 0x7a, 0x98, 0xf0, 0x21, 0xac, 0x66, 0xc1, 0xd0, 0x00,
+	0xf5, 0x9e, 0x33, 0xb8, 0x43, 0xa9, 0x33, 0xe1, 0x23, 0x58, 0xcd, 0x0a, 0x43, 0x03, 0xf4, 0x6d,
-	0x7d, 0x5f, 0x75, 0x50, 0x01, 0x67, 0x4d, 0x9c, 0xfe, 0x74, 0xc2, 0x51, 0x98, 0xf0, 0xaf, 0xc0,
+	0x35, 0x40, 0x85, 0x38, 0x6b, 0xc2, 0xfb, 0xd3, 0x05, 0x47, 0x21, 0xc2, 0x3f, 0x07, 0x3b, 0xb1,
-	0x4e, 0xec, 0xfb, 0x20, 0x08, 0x46, 0xc3, 0x3e, 0xfb, 0x7e, 0xac, 0x6f, 0xac, 0x9e, 0x0a, 0xd1,
+	0xef, 0x83, 0x20, 0x18, 0x0e, 0x7a, 0xec, 0xfb, 0xb1, 0xbe, 0xb1, 0x7a, 0xaa, 0x88, 0x56, 0xb9,
-	0x2a, 0x87, 0x68, 0xd8, 0xd8, 0x5b, 0x00, 0x0f, 0x43, 0x7f, 0x9c, 0xd9, 0x5a, 0x85, 0x82, 0xff,
+	0x88, 0x86, 0x83, 0xbd, 0x09, 0xf0, 0x30, 0xf4, 0x47, 0x99, 0xa3, 0x55, 0x30, 0xf8, 0x0f, 0x16,
-	0x64, 0xc1, 0x07, 0x85, 0xc2, 0x2b, 0x6d, 0xf3, 0x13, 0x58, 0x4d, 0xc2, 0xc1, 0x84, 0xd0, 0x48,
+	0xbc, 0x5f, 0xc8, 0x7c, 0xaa, 0x63, 0x7e, 0x02, 0xab, 0x49, 0x3a, 0x18, 0x13, 0x1a, 0x29, 0x27,
-	0xd9, 0xe9, 0x8f, 0x8a, 0x76, 0x45, 0xb0, 0x3a, 0xb9, 0x85, 0x38, 0x82, 0xad, 0x47, 0x24, 0x8a,
+	0xfd, 0x61, 0xd1, 0xa9, 0x08, 0x52, 0x47, 0xdb, 0x88, 0x23, 0xd8, 0x7e, 0x44, 0xa2, 0x58, 0x56,
-	0xb1, 0x3a, 0xe4, 0xc2, 0x60, 0x9c, 0xa2, 0xc0, 0x35, 0xdb, 0xbe, 0xfe, 0xd9, 0x82, 0x0f, 0x4b,
+	0x87, 0x5c, 0x1a, 0x8c, 0x53, 0x94, 0xb8, 0x66, 0x3b, 0xd7, 0x3f, 0x5a, 0xf0, 0x41, 0x09, 0xdb,
-	0xc4, 0x56, 0xda, 0x65, 0xa3, 0x5d, 0xe6, 0xaa, 0xda, 0xe5, 0x5f, 0x16, 0xb4, 0x9e, 0x87, 0x3d,
+	0xa9, 0x4e, 0xd9, 0x68, 0x97, 0xb9, 0x69, 0xed, 0xf2, 0x4f, 0x0b, 0x9a, 0xcf, 0xc3, 0xae, 0x47,
-	0x8f, 0x9e, 0x91, 0x90, 0x4d, 0xb2, 0x28, 0x15, 0x5b, 0xa4, 0x0d, 0x8b, 0xc2, 0xf5, 0x85, 0x49,
+	0xcf, 0x49, 0xc8, 0x16, 0x59, 0x96, 0x8a, 0x2d, 0xd2, 0x82, 0x45, 0x11, 0xfa, 0xc2, 0x24, 0x09,
-	0x92, 0x21, 0xfa, 0x14, 0xae, 0x9f, 0x8c, 0x5c, 0x35, 0xc2, 0x71, 0xcb, 0x68, 0xd4, 0x98, 0xef,
+	0x88, 0x3e, 0x86, 0x1b, 0xa7, 0x43, 0x57, 0xcd, 0x70, 0xdc, 0x32, 0x39, 0x6c, 0x4c, 0x77, 0x42,
-	0x98, 0xbc, 0x52, 0xf9, 0xb8, 0x89, 0x34, 0xaa, 0x6e, 0xc7, 0x6b, 0xe5, 0x51, 0xa5, 0xa6, 0x45,
+	0x5e, 0xa9, 0x74, 0xdc, 0x44, 0x39, 0x6c, 0xde, 0x8e, 0xf3, 0xe5, 0x59, 0xa5, 0x9a, 0xcb, 0x2a,
-	0x95, 0x27, 0xb0, 0x61, 0x52, 0xa0, 0x9a, 0x07, 0x7d, 0x65, 0xc1, 0xca, 0x63, 0x7f, 0xe8, 0xc9,
+	0x4f, 0x60, 0xc3, 0xa4, 0xc0, 0x74, 0x11, 0xf4, 0x85, 0x05, 0x2b, 0x8f, 0xfd, 0x81, 0x27, 0xef,
-	0x7b, 0xa8, 0xd8, 0x0a, 0xb7, 0x00, 0x1c, 0x72, 0xd1, 0x25, 0x94, 0xf6, 0x06, 0x44, 0x58, 0x40,
+	0xa1, 0x62, 0x2b, 0xdc, 0x04, 0x70, 0xc8, 0x65, 0x87, 0x50, 0xda, 0xed, 0x13, 0x61, 0x01, 0x05,
-	0xa1, 0x94, 0x45, 0xc2, 0xab, 0x35, 0xc6, 0x7b, 0xd0, 0x50, 0x70, 0x54, 0x53, 0xe6, 0x3f, 0xb1,
+	0x53, 0x96, 0x09, 0xaf, 0xd7, 0x18, 0xef, 0x43, 0x5d, 0x91, 0x63, 0x3a, 0x65, 0xfe, 0x1d, 0x87,
-	0x4b, 0x6a, 0xfe, 0x18, 0x4f, 0xf8, 0x1e, 0x25, 0x22, 0xde, 0xab, 0x28, 0xac, 0x72, 0xbb, 0xeb,
+	0x64, 0x2e, 0x1e, 0xe3, 0x05, 0xdf, 0xa3, 0x44, 0xe4, 0x7b, 0x55, 0x0a, 0xab, 0xdc, 0xee, 0x79,
-	0xa7, 0x5f, 0xb1, 0xcc, 0x7c, 0xce, 0x32, 0x4a, 0xa8, 0xb8, 0xa6, 0x87, 0x8a, 0x78, 0xfe, 0xa8,
+	0xef, 0x57, 0x2c, 0x53, 0xd1, 0x2c, 0xa3, 0xa4, 0x8a, 0xf9, 0x7c, 0xaa, 0x88, 0xd7, 0x8f, 0xbb,
-	0xe7, 0xb9, 0x23, 0xe2, 0xc6, 0x4e, 0xcf, 0xf7, 0x53, 0xa1, 0x20, 0x0c, 0x2b, 0x7c, 0xe4, 0x10,
+	0x9e, 0x3b, 0x24, 0x6e, 0x1c, 0xf4, 0xfc, 0x3c, 0x15, 0x0c, 0xc2, 0xb0, 0xc2, 0x21, 0x87, 0xd0,
-	0x3a, 0x19, 0x45, 0xed, 0x05, 0x16, 0x2f, 0x32, 0x34, 0xfc, 0x0c, 0xb6, 0x8a, 0x55, 0xab, 0x66,
+	0xf1, 0x30, 0x6a, 0x2d, 0xb0, 0x7c, 0x91, 0xc1, 0xe1, 0x67, 0xb0, 0x5d, 0xac, 0xda, 0x74, 0xe6,
-	0xae, 0x33, 0x58, 0x79, 0x36, 0x19, 0x46, 0x53, 0x6c, 0xfd, 0x6c, 0xd7, 0xe0, 0x1e, 0x34, 0x14,
+	0x3a, 0x87, 0x95, 0x67, 0xe3, 0x41, 0x34, 0xc1, 0xd1, 0xcf, 0x76, 0x0d, 0xee, 0x43, 0x5d, 0xe1,
-	0x39, 0xd5, 0xb0, 0xbe, 0xb6, 0xa0, 0x95, 0x44, 0xdb, 0x34, 0xe5, 0x29, 0x47, 0x3d, 0x53, 0x28,
+	0x33, 0x9d, 0xac, 0x5f, 0x59, 0xd0, 0x4c, 0xb2, 0x6d, 0x5a, 0xf2, 0x94, 0x4b, 0x3d, 0x53, 0x2a,
-	0x8b, 0x03, 0xe4, 0xc3, 0xe1, 0x28, 0x22, 0x21, 0xdb, 0xd0, 0x9a, 0x23, 0x46, 0xb1, 0xbc, 0x63,
+	0x8b, 0x13, 0xe4, 0xc3, 0xc1, 0x30, 0x22, 0x21, 0x3b, 0xd0, 0xaa, 0x23, 0xa0, 0x98, 0xdf, 0x09,
-	0xf2, 0x8b, 0xe8, 0x94, 0x5c, 0xb0, 0x9d, 0xac, 0x39, 0xc9, 0x10, 0xff, 0xcd, 0x82, 0x0d, 0x13,
+	0xf9, 0x69, 0x74, 0x46, 0x2e, 0xd9, 0x49, 0x56, 0x9d, 0x04, 0xc4, 0x7f, 0xb5, 0x60, 0xc3, 0x24,
-	0xc6, 0x4a, 0x97, 0xc1, 0x43, 0x80, 0x71, 0x9a, 0x0b, 0xf2, 0x6b, 0xe0, 0xd3, 0xa2, 0x70, 0xc7,
+	0xe3, 0x54, 0x97, 0xc1, 0x43, 0x80, 0x51, 0x5a, 0x0b, 0xf2, 0x6b, 0xe0, 0xe3, 0xa2, 0x74, 0xc7,
-	0xa5, 0x3d, 0x9c, 0x8c, 0x46, 0xec, 0x36, 0x55, 0x56, 0xc6, 0x92, 0x3d, 0x01, 0x97, 0xeb, 0x91,
+	0xb9, 0x3d, 0x1c, 0x0f, 0x87, 0xec, 0x36, 0x55, 0x76, 0xc6, 0x9c, 0x3d, 0x21, 0x2e, 0xd7, 0x23,
-	0x0c, 0xf1, 0xef, 0x73, 0x70, 0x65, 0x62, 0x54, 0x1a, 0x04, 0x14, 0x58, 0x73, 0x2c, 0x63, 0x52,
+	0x01, 0xf1, 0x6f, 0x34, 0x71, 0x65, 0x61, 0x54, 0x9a, 0x04, 0x14, 0xb1, 0xe6, 0x58, 0xc5, 0xa4,
-	0xc5, 0xcd, 0x16, 0x04, 0xfe, 0x68, 0xc1, 0xa6, 0x11, 0xd2, 0xfb, 0x34, 0x21, 0xfe, 0xbb, 0x05,
+	0xb2, 0x9b, 0x2d, 0x09, 0xfc, 0xce, 0x82, 0x4d, 0xa3, 0x48, 0xef, 0xd2, 0x84, 0xf8, 0x6f, 0x16,
-	0xe8, 0xc9, 0xb0, 0x7f, 0xae, 0xf0, 0x95, 0x1b, 0xe9, 0xdb, 0xb0, 0x1a, 0xf3, 0x13, 0x97, 0x2b,
+	0xa0, 0x27, 0x83, 0xde, 0x85, 0x42, 0x57, 0x6e, 0xa4, 0xaf, 0xc3, 0x6a, 0x4c, 0x4f, 0x5c, 0xae,
-	0xae, 0x98, 0x2a, 0x47, 0x8f, 0xc1, 0x3b, 0xa4, 0x47, 0x7d, 0x4f, 0x98, 0x4b, 0x8c, 0x74, 0x63,
+	0xb8, 0x62, 0x2a, 0x0d, 0x1f, 0x0b, 0xef, 0x90, 0x2e, 0xf5, 0x3d, 0x61, 0x2e, 0x01, 0xe5, 0x8d,
-	0xd5, 0xca, 0x5d, 0x6e, 0x41, 0x73, 0xb9, 0xcf, 0xa1, 0xde, 0x71, 0xef, 0xf2, 0xd0, 0x51, 0x78,
+	0x55, 0x2d, 0x0f, 0xb9, 0x85, 0x5c, 0xc8, 0x7d, 0x0a, 0xb5, 0xb6, 0x7b, 0x97, 0xa7, 0x8e, 0xc2,
-	0xd5, 0x33, 0xd1, 0x2c, 0xe0, 0xf0, 0x02, 0x45, 0x8c, 0xf0, 0x97, 0xb0, 0x9e, 0x53, 0xb7, 0xd2,
+	0xab, 0x9e, 0xb1, 0x66, 0x09, 0x87, 0x37, 0x28, 0x02, 0xc2, 0x9f, 0xc3, 0xba, 0xa6, 0xee, 0x54,
-	0x06, 0xdc, 0x83, 0x86, 0x44, 0xa1, 0xec, 0xc1, 0xaa, 0x70, 0x75, 0x39, 0xe7, 0x64, 0xd9, 0xf0,
+	0x07, 0x70, 0x0f, 0xea, 0x52, 0x0a, 0xe5, 0x0c, 0x56, 0x45, 0xa8, 0xcb, 0x35, 0x27, 0x4b, 0x86,
-	0x84, 0xf9, 0x7a, 0x7c, 0x1d, 0x10, 0x97, 0xa1, 0x48, 0x7c, 0x3d, 0x1b, 0x68, 0xad, 0x5c, 0xa0,
+	0xc7, 0x2c, 0xd6, 0xe3, 0xeb, 0x80, 0xb8, 0x4c, 0x8a, 0x24, 0xd6, 0xb3, 0x89, 0xd6, 0xd2, 0x12,
-	0xdd, 0x86, 0x65, 0x3f, 0x1f, 0xa7, 0xfc, 0x29, 0xe3, 0xd4, 0x57, 0xdc, 0x21, 0x72, 0x72, 0x67,
+	0xed, 0x0e, 0x2c, 0xfb, 0x7a, 0x9e, 0xf2, 0x27, 0xcc, 0x53, 0x5f, 0xf0, 0x80, 0xd0, 0xf8, 0xce,
-	0xaa, 0x55, 0xa6, 0xce, 0xd7, 0x53, 0x76, 0xfc, 0x0f, 0x0b, 0x6e, 0x74, 0xbc, 0xcb, 0x61, 0x44,
+	0xd4, 0xab, 0x4c, 0x5c, 0xaf, 0xa7, 0xe4, 0xf8, 0xef, 0x16, 0xbc, 0xd7, 0xf6, 0xae, 0x06, 0x11,
-	0x62, 0x64, 0xcf, 0x7d, 0x19, 0xa1, 0xaf, 0x8e, 0xc3, 0xc5, 0x97, 0x54, 0x7a, 0xd0, 0xae, 0x65,
+	0x89, 0x25, 0x7b, 0xee, 0xcb, 0x0c, 0x7d, 0x7d, 0x1e, 0x2e, 0xbe, 0xa4, 0x52, 0x47, 0x9b, 0xcf,
-	0x0e, 0xda, 0x77, 0x61, 0x8d, 0xcb, 0x52, 0x4f, 0x6b, 0x8d, 0x9d, 0xd6, 0xfc, 0x44, 0xe9, 0xa1,
+	0x38, 0xda, 0x37, 0x61, 0x8d, 0xf3, 0x52, 0xbd, 0xb5, 0xca, 0xbc, 0x55, 0x5f, 0x28, 0x75, 0xba,
-	0xfb, 0xb5, 0x05, 0x2d, 0x03, 0xec, 0xff, 0xeb, 0xd1, 0xf1, 0xe0, 0x86, 0x4c, 0xca, 0x47, 0xa3,
+	0x5f, 0x58, 0xd0, 0x34, 0x88, 0xfd, 0x7f, 0x75, 0x1d, 0x0f, 0xde, 0x93, 0x45, 0xf9, 0x70, 0x38,
-	0x69, 0x9c, 0x75, 0xb6, 0x84, 0xf7, 0x0f, 0xca, 0xbd, 0xa4, 0x08, 0x7c, 0xaf, 0xf1, 0xea, 0x1b,
+	0x49, 0xb0, 0xce, 0x56, 0xf0, 0xfe, 0x56, 0xb9, 0x97, 0x14, 0x86, 0xef, 0x34, 0x5f, 0xfd, 0xde,
-	0x0b, 0x96, 0xf6, 0xbb, 0xa7, 0x8c, 0x6d, 0xa6, 0x1a, 0xef, 0x0e, 0x34, 0xb9, 0xac, 0x1e, 0x8d,
+	0x82, 0xa5, 0x83, 0xce, 0x19, 0x23, 0x9b, 0xa9, 0xc7, 0xbb, 0x03, 0x0d, 0xce, 0xab, 0x4b, 0x23,
-	0x48, 0x78, 0xdc, 0x1b, 0x27, 0x69, 0x9f, 0x4e, 0x46, 0xb7, 0x45, 0x85, 0xca, 0x49, 0x1d, 0x57,
+	0x12, 0x9e, 0x74, 0x47, 0x49, 0xd9, 0x97, 0x47, 0xa3, 0xdb, 0xa2, 0x43, 0xe5, 0xa8, 0xb6, 0x2b,
-	0x98, 0x2a, 0x4b, 0x8c, 0xc3, 0xfb, 0x72, 0x62, 0xac, 0x78, 0x53, 0xb6, 0x04, 0x36, 0xf6, 0x65,
+	0x4c, 0x95, 0x45, 0xc6, 0xe9, 0x7d, 0x39, 0x31, 0x56, 0x7c, 0x28, 0xdb, 0x42, 0x36, 0xf6, 0x65,
-	0xbe, 0x2d, 0x29, 0x01, 0x1d, 0x00, 0xfc, 0xa4, 0x37, 0x18, 0x7a, 0xcc, 0xd4, 0xa2, 0x9f, 0x71,
+	0x7e, 0x2c, 0x29, 0x02, 0x1d, 0x02, 0xfc, 0xa0, 0xdb, 0x1f, 0x78, 0xcc, 0xd4, 0x62, 0x9e, 0x71,
-	0xdb, 0x00, 0x5d, 0x64, 0xf7, 0x29, 0xaf, 0xa3, 0xac, 0x9b, 0x62, 0x0b, 0x5f, 0x5b, 0xb0, 0x92,
+	0xdb, 0x20, 0xba, 0xa8, 0xee, 0x53, 0x5a, 0x47, 0xd9, 0x37, 0xc1, 0x11, 0x7e, 0x65, 0xc1, 0x4a,
-	0xa2, 0xa2, 0x01, 0xfa, 0x1e, 0xd4, 0x13, 0xf3, 0x51, 0xd1, 0x85, 0x69, 0x26, 0xd9, 0x89, 0xa0,
+	0x2a, 0x15, 0x0d, 0xd0, 0xb7, 0xa0, 0x96, 0x98, 0x8f, 0x8a, 0x29, 0x4c, 0x23, 0xa9, 0x4e, 0x04,
-	0x3b, 0x29, 0xc7, 0x5b, 0xc2, 0x29, 0x6d, 0x31, 0x19, 0x53, 0x86, 0xb2, 0xe6, 0xa4, 0x04, 0x7c,
+	0xde, 0x49, 0x29, 0xde, 0x90, 0x9c, 0xd2, 0x16, 0xe3, 0x11, 0x65, 0x52, 0x56, 0x9d, 0x14, 0x81,
-	0x99, 0x42, 0xa4, 0xb1, 0xe5, 0xb2, 0x32, 0xad, 0xb7, 0x63, 0x9b, 0x7c, 0x38, 0xc1, 0x7f, 0xb1,
+	0xaf, 0x52, 0x11, 0x69, 0x6c, 0xb9, 0x2c, 0x4f, 0xeb, 0xcd, 0xd8, 0x46, 0x4f, 0x27, 0xf8, 0x4f,
-	0xa0, 0xa1, 0x08, 0x7e, 0x5f, 0xc6, 0xb1, 0x61, 0x29, 0xb1, 0x85, 0xb0, 0x8d, 0x1c, 0xe3, 0x93,
+	0x16, 0xd4, 0x15, 0xc6, 0xef, 0xca, 0x38, 0x36, 0x2c, 0x25, 0xb6, 0x10, 0xb6, 0x91, 0x30, 0x3e,
-	0xb4, 0xc7, 0x62, 0x70, 0x77, 0x37, 0xeb, 0xee, 0xee, 0x14, 0x3a, 0x9f, 0x43, 0x8b, 0x0f, 0x79,
+	0x4d, 0x67, 0x2c, 0x86, 0x70, 0x77, 0xb3, 0xe1, 0xee, 0x4e, 0xa0, 0xf3, 0x05, 0x34, 0x39, 0xc8,
-	0xaf, 0xea, 0x34, 0xea, 0x45, 0x13, 0x5a, 0xfe, 0xd1, 0x0d, 0x58, 0xe0, 0x6c, 0xc9, 0x4d, 0xca,
+	0x67, 0x55, 0x67, 0x51, 0x37, 0x1a, 0xd3, 0xf2, 0x8f, 0x6e, 0xc0, 0x02, 0x27, 0x4b, 0x6e, 0x52,
-	0x47, 0x53, 0x1c, 0xbe, 0x36, 0x6c, 0x98, 0x84, 0xf1, 0xca, 0x0c, 0x89, 0x29, 0x56, 0x4e, 0xfb,
+	0x0e, 0x4d, 0xe0, 0x7c, 0x2d, 0xd8, 0x30, 0x31, 0xe3, 0x9d, 0x19, 0x12, 0x4b, 0xac, 0x9d, 0xf6,
-	0x23, 0x72, 0x25, 0x08, 0x16, 0xb6, 0xdc, 0x24, 0xac, 0xf0, 0x51, 0xb6, 0x15, 0x39, 0xaf, 0xb5,
+	0x87, 0xe4, 0x5a, 0x21, 0x58, 0xda, 0x72, 0x93, 0xb4, 0xc2, 0xa1, 0xec, 0x28, 0xb2, 0x92, 0x1b,
-	0x22, 0xa7, 0x48, 0xca, 0x5a, 0xb0, 0x9e, 0xc3, 0x41, 0x03, 0xfc, 0x14, 0xae, 0x1f, 0x90, 0x11,
+	0x45, 0x4e, 0x50, 0x94, 0x35, 0x61, 0x5d, 0x93, 0x83, 0x06, 0xf8, 0x29, 0xdc, 0x38, 0x24, 0x43,
-	0x51, 0x5a, 0x98, 0xb3, 0x18, 0x7d, 0x0d, 0x9a, 0x99, 0xaf, 0xd1, 0x00, 0x77, 0xa1, 0x99, 0x6c,
+	0xa2, 0x8c, 0x30, 0x67, 0x31, 0xfa, 0x1a, 0x34, 0x32, 0x5f, 0xa3, 0x01, 0xee, 0x40, 0x23, 0x39,
-	0xec, 0xde, 0x2f, 0x3b, 0xee, 0xac, 0x12, 0xee, 0xa7, 0x0d, 0x40, 0xfe, 0x39, 0x1a, 0xa0, 0xef,
+	0xd8, 0xfd, 0x9f, 0xb5, 0xdd, 0x59, 0x39, 0xdc, 0x4f, 0x07, 0x80, 0xfc, 0x73, 0x34, 0x40, 0xdf,
-	0xa4, 0x81, 0x52, 0x38, 0x51, 0xee, 0x2c, 0x4b, 0x06, 0xfc, 0xcf, 0x5c, 0x09, 0x42, 0xf7, 0xbb,
+	0x48, 0x13, 0xa5, 0x08, 0x22, 0xcd, 0x97, 0x25, 0x01, 0xfe, 0x87, 0xd6, 0x82, 0xd0, 0x83, 0xce,
-	0xa7, 0xe5, 0xb0, 0x6c, 0x58, 0x8a, 0x8d, 0xa6, 0x84, 0x4e, 0x39, 0xd6, 0x5c, 0x63, 0xfe, 0xed,
+	0x59, 0xb9, 0x58, 0x36, 0x2c, 0xc5, 0x46, 0x53, 0x52, 0xa7, 0x84, 0x73, 0xa1, 0x51, 0x79, 0x33,
-	0xf8, 0xb0, 0x61, 0xff, 0xfe, 0x9d, 0xcf, 0xf3, 0x19, 0x6e, 0x1a, 0xa0, 0x1f, 0xc3, 0x22, 0xbf,
+	0x31, 0x6c, 0x38, 0xbf, 0x7f, 0xe9, 0x75, 0x3e, 0x93, 0x9b, 0x06, 0xe8, 0xfb, 0xb0, 0xc8, 0xef,
-	0x37, 0x12, 0x57, 0x9e, 0xf6, 0xba, 0x49, 0x96, 0xa1, 0x43, 0x83, 0x7f, 0x7f, 0xcb, 0xa8, 0x04,
+	0x8d, 0x24, 0x94, 0x27, 0xbd, 0x6e, 0x92, 0x6d, 0xe8, 0xc8, 0x10, 0xdf, 0x5f, 0x33, 0x2a, 0xc1,
-	0xaf, 0x55, 0x0b, 0xb4, 0xb8, 0x05, 0xc0, 0x25, 0x28, 0xe1, 0x4f, 0xa1, 0xe0, 0xdf, 0x59, 0xd0,
+	0x7b, 0xd5, 0x02, 0x2d, 0x6e, 0x02, 0x70, 0x0e, 0x4a, 0xfa, 0x53, 0x30, 0xf8, 0xd7, 0x16, 0xb4,
-	0x76, 0xc8, 0xd8, 0xbf, 0x24, 0x6f, 0x64, 0xfe, 0x36, 0x2c, 0x72, 0x27, 0xa0, 0x22, 0xff, 0x4e,
+	0x1c, 0x32, 0xf2, 0xaf, 0xc8, 0x6b, 0x99, 0xbf, 0x05, 0x8b, 0x3c, 0x08, 0xa8, 0xa8, 0xbf, 0x13,
-	0x86, 0x6f, 0xd4, 0xef, 0x76, 0xb5, 0x7e, 0xb7, 0x8b, 0xbb, 0x70, 0xb3, 0x00, 0x0d, 0xbf, 0xf8,
+	0xf0, 0xb5, 0xe6, 0xdd, 0x6e, 0x6e, 0xde, 0xed, 0xe2, 0x0e, 0x6c, 0x15, 0x48, 0xc3, 0x2f, 0x7e,
-	0xe9, 0xa4, 0xdf, 0x27, 0x94, 0x8a, 0x8e, 0x72, 0x32, 0x8c, 0x3d, 0xf4, 0xac, 0x37, 0x1c, 0x11,
+	0x3a, 0xee, 0xf5, 0x08, 0xa5, 0x62, 0xa2, 0x9c, 0x80, 0x71, 0x84, 0x9e, 0x77, 0x07, 0x43, 0xe2,
-	0x57, 0xa0, 0x11, 0x23, 0xfc, 0xb5, 0x05, 0xad, 0x07, 0xae, 0xfb, 0x2e, 0x54, 0x73, 0xf3, 0xaa,
+	0x0a, 0x69, 0x04, 0x84, 0xbf, 0xb4, 0xa0, 0xf9, 0xc0, 0x75, 0xdf, 0x86, 0x6a, 0xae, 0xae, 0x9a,
-	0xb9, 0xa5, 0xaa, 0x3d, 0x86, 0x0d, 0x13, 0x94, 0x4a, 0x7a, 0x0d, 0xa1, 0x79, 0x30, 0xa4, 0xe3,
+	0x5b, 0xaa, 0xda, 0x63, 0xd8, 0x30, 0x89, 0x32, 0x95, 0x5e, 0x03, 0x68, 0x1c, 0x0e, 0xe8, 0x68,
-	0x21, 0xa5, 0x32, 0x46, 0xd8, 0xb0, 0xe4, 0x6b, 0x3d, 0x59, 0x3f, 0x98, 0x3a, 0x7b, 0x6f, 0xc3,
+	0x40, 0xa9, 0xcc, 0x11, 0x36, 0x2c, 0xf9, 0xb9, 0x99, 0xac, 0x1f, 0x4c, 0x5c, 0xbd, 0xb7, 0x60,
-	0xe2, 0x20, 0x9b, 0xdd, 0x8a, 0x21, 0x3e, 0x84, 0xd5, 0xac, 0x28, 0xde, 0x66, 0xe8, 0x4f, 0xd3,
+	0xb1, 0x9f, 0xad, 0x6e, 0x05, 0x88, 0x8f, 0x60, 0x35, 0xcb, 0x8a, 0x8f, 0x19, 0x7a, 0x93, 0x8c,
-	0x66, 0x48, 0x99, 0xf0, 0x5f, 0x2d, 0x40, 0xdd, 0x49, 0x44, 0xb4, 0xeb, 0xe4, 0x1d, 0xa1, 0x8e,
+	0x19, 0x52, 0x22, 0xfc, 0x17, 0x0b, 0x50, 0x67, 0x1c, 0x91, 0xdc, 0x75, 0xf2, 0x96, 0xa4, 0x8e,
-	0x0d, 0x37, 0x51, 0x9b, 0x46, 0x62, 0x84, 0x30, 0xac, 0x8c, 0x27, 0x11, 0x71, 0x4f, 0x49, 0xdf,
+	0x0d, 0x37, 0x56, 0x87, 0x46, 0x02, 0x42, 0x18, 0x56, 0x46, 0xe3, 0x88, 0xb8, 0x67, 0xa4, 0xe7,
-	0xf7, 0x5c, 0xca, 0xaa, 0xbf, 0x86, 0x93, 0xa1, 0xe1, 0x23, 0x58, 0xcf, 0x21, 0xad, 0xa6, 0xf4,
+	0x7b, 0x2e, 0x65, 0xdd, 0x5f, 0xdd, 0xc9, 0xe0, 0xf0, 0x31, 0xac, 0x6b, 0x92, 0x4e, 0xa7, 0xf4,
-	0x6f, 0x2c, 0x68, 0xef, 0xf7, 0xbc, 0x3e, 0x19, 0xbd, 0x7f, 0xd5, 0xf1, 0x31, 0xdc, 0x2c, 0xc0,
+	0x2f, 0x2d, 0x68, 0x1d, 0x74, 0xbd, 0x1e, 0x19, 0xbe, 0x7b, 0xd5, 0xf1, 0x09, 0x6c, 0x15, 0xc8,
-	0x52, 0x4d, 0xb9, 0x33, 0x58, 0x91, 0x5f, 0x7a, 0x97, 0x07, 0x70, 0x0f, 0x1a, 0x8a, 0x9c, 0x6a,
+	0x32, 0x9d, 0x72, 0xe7, 0xb0, 0x22, 0xbf, 0xf4, 0x36, 0x1d, 0x70, 0x1f, 0xea, 0x0a, 0x9f, 0xe9,
-	0x58, 0x47, 0x80, 0x34, 0xdd, 0xdf, 0x25, 0xe2, 0x23, 0x58, 0xcf, 0x49, 0xab, 0x84, 0xfb, 0xee,
+	0x64, 0x1d, 0x02, 0xca, 0xe9, 0xfe, 0x36, 0x25, 0x3e, 0x86, 0x75, 0x8d, 0xdb, 0x74, 0x72, 0xff,
-	0x37, 0x6b, 0xc0, 0xdf, 0x61, 0xd1, 0x0f, 0x61, 0xb9, 0x9f, 0x3e, 0xf3, 0xa1, 0x56, 0xb2, 0x2e,
+	0xd9, 0x82, 0xad, 0xb3, 0xcc, 0x0d, 0x73, 0x32, 0xe8, 0x5d, 0x78, 0xdd, 0x51, 0x52, 0xb1, 0xf4,
-	0xf3, 0xd6, 0x69, 0x6f, 0x98, 0xc8, 0x34, 0x40, 0xf7, 0xa0, 0xfe, 0xf3, 0xa4, 0x07, 0x8c, 0xd6,
+	0xb3, 0xad, 0x57, 0x3f, 0x6d, 0xbd, 0x3c, 0x41, 0x98, 0xdc, 0x8e, 0x09, 0x9c, 0xd1, 0xba, 0x52,
-	0x05, 0x93, 0xda, 0x9d, 0xb6, 0x6f, 0xe4, 0x89, 0x7c, 0xdd, 0x45, 0xd2, 0x60, 0x94, 0xeb, 0xd4,
+	0xae, 0xf5, 0xbc, 0xae, 0x75, 0xea, 0x5d, 0xd5, 0x8c, 0x77, 0x9d, 0x82, 0x5d, 0x24, 0xe8, 0x54,
-	0xd6, 0xa6, 0x5c, 0x97, 0xed, 0x43, 0xee, 0x41, 0x63, 0xa0, 0x3e, 0xcf, 0xa1, 0xcd, 0xe4, 0xb1,
+	0x73, 0xc9, 0xbb, 0xff, 0x5d, 0x03, 0xfe, 0x04, 0x8d, 0xbe, 0x0b, 0xcb, 0xbd, 0xf4, 0x85, 0x13,
-	0x55, 0x7b, 0x29, 0xb4, 0xdb, 0xe6, 0x09, 0x1a, 0xa0, 0xfb, 0xb0, 0x42, 0x95, 0x97, 0x2c, 0x94,
+	0x35, 0x93, 0x7d, 0x99, 0x67, 0x5e, 0x7b, 0xc3, 0x84, 0xa6, 0x01, 0xba, 0x07, 0xb5, 0x9f, 0x24,
-	0xe8, 0xa6, 0xbd, 0xb5, 0xd9, 0x9b, 0x46, 0x3a, 0x0d, 0xd0, 0xcf, 0x60, 0x73, 0x60, 0x7e, 0x46,
+	0xe3, 0x6f, 0xb4, 0x2e, 0x88, 0xd4, 0xc1, 0xbc, 0xfd, 0x9e, 0x8e, 0xe4, 0xfb, 0x2e, 0x93, 0xd9,
-	0x42, 0x1f, 0x6b, 0x52, 0xf3, 0xcf, 0x38, 0x36, 0xbe, 0x8a, 0x85, 0x06, 0xe8, 0x0c, 0x6e, 0x0e,
+	0xaa, 0xdc, 0xa7, 0x4e, 0x75, 0xe5, 0xbe, 0xec, 0x08, 0x76, 0x1f, 0xea, 0x7d, 0xf5, 0x65, 0x12,
-	0x8a, 0xde, 0x64, 0xd0, 0x27, 0xe9, 0x07, 0x0a, 0x1f, 0x8b, 0xec, 0xdb, 0x57, 0x33, 0xd1, 0x00,
+	0x6d, 0x26, 0xef, 0xcc, 0xb9, 0x47, 0x52, 0xbb, 0x65, 0x5e, 0xa0, 0x01, 0xba, 0x0f, 0x2b, 0x54,
-	0x3d, 0x03, 0x14, 0xe5, 0x1e, 0x26, 0xd0, 0x96, 0x58, 0x6b, 0x7c, 0x74, 0xb1, 0x3f, 0x2c, 0x99,
+	0x79, 0xc4, 0x43, 0x89, 0x6e, 0xb9, 0x67, 0x46, 0x7b, 0xd3, 0x88, 0xa7, 0x01, 0xfa, 0x31, 0x6c,
-	0xa5, 0x01, 0xea, 0x43, 0x7b, 0x50, 0xd0, 0xf5, 0x46, 0x38, 0xf3, 0x32, 0x6e, 0xec, 0xf8, 0xdb,
+	0xf6, 0xcd, 0x2f, 0x68, 0xe8, 0x56, 0x8e, 0xab, 0xfe, 0x82, 0x65, 0xe3, 0xeb, 0x48, 0x68, 0x80,
-	0x9f, 0x5c, 0xc9, 0xc3, 0x71, 0x0f, 0x72, 0x6d, 0x5b, 0x89, 0xdb, 0xd8, 0x75, 0x96, 0xb8, 0x0b,
+	0xce, 0x61, 0xab, 0x5f, 0xf4, 0x1c, 0x85, 0x3e, 0x4a, 0x3f, 0x50, 0xf8, 0x4e, 0x66, 0xdf, 0xbe,
-	0xfa, 0xbd, 0xcf, 0x61, 0x7d, 0x90, 0xef, 0x63, 0x22, 0xf3, 0x2a, 0x79, 0xca, 0x6e, 0x95, 0x4d,
+	0x9e, 0x88, 0x06, 0xe8, 0x19, 0xa0, 0x48, 0x7b, 0x93, 0x41, 0xdb, 0x62, 0xaf, 0xf1, 0xbd, 0xc9,
-	0xd3, 0x00, 0x1d, 0x41, 0xf3, 0x3c, 0xdb, 0x98, 0x43, 0xc9, 0xdf, 0x03, 0xf2, 0xfd, 0x49, 0xdb,
+	0xfe, 0xa0, 0x64, 0x95, 0x06, 0xa8, 0x07, 0xad, 0x7e, 0xc1, 0xc0, 0x1f, 0xe1, 0xcc, 0x9f, 0x02,
-	0x2e, 0x9a, 0x92, 0x2a, 0x6b, 0x9d, 0x2e, 0x55, 0xe5, 0x7c, 0xf3, 0x4d, 0x55, 0xd9, 0xd4, 0x22,
+	0x8c, 0x8f, 0x1d, 0xf6, 0x47, 0xd7, 0xd2, 0x70, 0xb9, 0xfb, 0xda, 0xc4, 0x5a, 0xca, 0x6d, 0x1c,
-	0x3b, 0x86, 0xb5, 0xa1, 0xde, 0xfc, 0x41, 0x1f, 0x24, 0xfd, 0x1a, 0x43, 0x37, 0xcb, 0xde, 0x2a,
+	0xb8, 0x4b, 0xb9, 0x0b, 0x46, 0xdd, 0xcf, 0x61, 0xbd, 0xaf, 0x8f, 0x70, 0x91, 0x79, 0x97, 0xf4,
-	0x9e, 0xe4, 0xdf, 0x1b, 0xe8, 0x8d, 0x15, 0xf9, 0x3d, 0x53, 0x8f, 0xc7, 0xde, 0x2a, 0x9e, 0xe4,
+	0xb2, 0x9b, 0x65, 0xcb, 0x34, 0x40, 0xc7, 0xd0, 0xb8, 0xc8, 0xce, 0x24, 0x51, 0xf2, 0xcf, 0x08,
-	0x8e, 0xaa, 0xe6, 0xff, 0xd2, 0x51, 0xb5, 0x1a, 0xc3, 0xde, 0x34, 0xd2, 0x69, 0x80, 0x3e, 0x83,
+	0x7d, 0x34, 0x6b, 0xdb, 0x45, 0x4b, 0x52, 0xe5, 0xdc, 0x90, 0x4f, 0x55, 0x59, 0x9f, 0x3b, 0xaa,
-	0xa5, 0x84, 0x86, 0x90, 0xc6, 0x14, 0x2f, 0x5c, 0xcf, 0xd1, 0x78, 0x68, 0x92, 0x31, 0x03, 0xe9,
+	0x2a, 0x9b, 0xa6, 0x83, 0x27, 0xb0, 0x36, 0xc8, 0xcf, 0xbd, 0xd0, 0xfb, 0xc9, 0xa8, 0xca, 0x30,
-	0x1c, 0x54, 0x0d, 0x4d, 0xd9, 0x32, 0xfb, 0x99, 0x2c, 0xfe, 0x94, 0xba, 0x50, 0x6e, 0x90, 0xb1,
+	0xc8, 0xb3, 0xb7, 0x8b, 0x17, 0xf9, 0xf7, 0xfa, 0xf9, 0x99, 0x92, 0xfc, 0x9e, 0x69, 0xbc, 0x65,
-	0x3e, 0x95, 0x1b, 0x64, 0x2e, 0x28, 0xe3, 0xd3, 0xa3, 0xd5, 0x71, 0xf2, 0xf4, 0xe4, 0xeb, 0x4c,
+	0x6f, 0x17, 0x2f, 0xf2, 0x40, 0x55, 0x5b, 0x1f, 0x19, 0xa8, 0xb9, 0xf6, 0xca, 0xde, 0x34, 0xe2,
-	0x79, 0x7a, 0x0c, 0xa5, 0x5f, 0x1c, 0xe5, 0x95, 0x62, 0x4d, 0x46, 0xf9, 0x6c, 0x39, 0x28, 0xa3,
+	0x69, 0x80, 0x3e, 0x81, 0xa5, 0x04, 0x87, 0x50, 0x8e, 0x28, 0xde, 0xb8, 0xae, 0xe1, 0x78, 0x6a,
-	0xbc, 0x56, 0xd7, 0xc5, 0xaa, 0xe5, 0xcb, 0x91, 0x02, 0x77, 0x13, 0x79, 0x70, 0x81, 0xbb, 0xc9,
+	0x92, 0x39, 0x03, 0xe5, 0x29, 0xa8, 0x9a, 0x9a, 0xb2, 0x13, 0x86, 0x67, 0xb2, 0xef, 0x55, 0x5a,
-	0xd4, 0xf4, 0x05, 0xb4, 0x8c, 0xf9, 0x38, 0xfa, 0x48, 0xac, 0x2b, 0xaa, 0x1d, 0xec, 0xed, 0x72,
+	0x62, 0x79, 0x40, 0xc6, 0xd6, 0x5c, 0x1e, 0x90, 0xb9, 0x97, 0x8e, 0xbd, 0x27, 0xd7, 0xc2, 0x4a,
-	0x06, 0x0e, 0x37, 0x9f, 0x10, 0x4b, 0xb8, 0xc6, 0xb4, 0x5d, 0xc2, 0x2d, 0xc8, 0xa4, 0xef, 0xc3,
+	0xef, 0xd1, 0x5b, 0x6c, 0xe9, 0x3d, 0x86, 0xae, 0x37, 0xce, 0xf2, 0x4a, 0x9f, 0x2a, 0xb3, 0x7c,
-	0x8a, 0x9a, 0xac, 0xca, 0xa3, 0xa8, 0x25, 0xcb, 0xf2, 0x28, 0xe6, 0x32, 0xdb, 0x23, 0x68, 0x6a,
+	0xb6, 0x13, 0x96, 0x59, 0x3e, 0xd7, 0xd2, 0xc6, 0xaa, 0xe9, 0x9d, 0x58, 0x41, 0xb8, 0x89, 0x16,
-	0xe9, 0x91, 0xdc, 0xca, 0x7c, 0x0a, 0x27, 0xb7, 0xd2, 0x94, 0x51, 0xbd, 0x80, 0x96, 0x31, 0xdd,
+	0xa0, 0x20, 0xdc, 0x64, 0x55, 0xfe, 0x02, 0x9a, 0xc6, 0x56, 0x04, 0x7d, 0x28, 0xf6, 0x15, 0xb5,
-	0x92, 0x96, 0x2b, 0x4a, 0x0c, 0xa5, 0xe5, 0x8a, 0xb3, 0xb5, 0x7b, 0x50, 0x97, 0x64, 0x79, 0xf6,
+	0x4d, 0xf6, 0x4e, 0x39, 0x01, 0x17, 0x57, 0xef, 0x05, 0xa4, 0xb8, 0xc6, 0x8e, 0x45, 0x8a, 0x5b,
-	0xd5, 0xd4, 0x46, 0x9e, 0xfd, 0x6c, 0x06, 0x72, 0x04, 0x4d, 0xed, 0xa3, 0x52, 0xbb, 0x7c, 0x7a,
+	0xd0, 0x44, 0xdc, 0x87, 0x15, 0xb5, 0x4e, 0x97, 0xae, 0x98, 0xeb, 0x13, 0xa4, 0x2b, 0x6a, 0x45,
-	0x24, 0xb5, 0x33, 0xe4, 0x32, 0x7b, 0xcd, 0x17, 0x8d, 0x1d, 0xfe, 0x77, 0xb1, 0xcf, 0xd9, 0xef,
+	0xfd, 0x31, 0x34, 0x72, 0x95, 0xa1, 0x3c, 0x4a, 0xbd, 0x7a, 0x95, 0x47, 0x69, 0x2a, 0x26, 0x5f,
-	0x17, 0x0b, 0xec, 0xbf, 0x60, 0x9f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x2b, 0x24, 0xa7,
+	0x40, 0xd3, 0x58, 0x69, 0x4a, 0xcb, 0x15, 0xd5, 0xc4, 0xd2, 0x72, 0xc5, 0x85, 0xea, 0x3d, 0xa8,
-	0x4a, 0x26, 0x00, 0x00,
+	0x49, 0xb4, 0xf4, 0x7d, 0xb5, 0xaa, 0x93, 0xbe, 0x9f, 0x2d, 0xbe, 0x8e, 0xa1, 0x91, 0xfb, 0xa8,
+	0xd4, 0x4e, 0xaf, 0x0c, 0xa5, 0x76, 0xa6, 0x32, 0xee, 0x47, 0xb0, 0x61, 0xae, 0x74, 0xd0, 0x4e,
+	0xee, 0x3a, 0xd6, 0x2a, 0x36, 0xfb, 0xd6, 0x35, 0x14, 0x34, 0xd8, 0x6f, 0xbc, 0xa8, 0xef, 0xf2,
+	0x3f, 0xe2, 0x7d, 0xca, 0x7e, 0x3f, 0x5b, 0x60, 0xff, 0xb2, 0xfb, 0xe4, 0x7f, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x14, 0x45, 0xba, 0x3b, 0xa4, 0x27, 0x00, 0x00,
 }

pkg/proto/group/group.proto

@@ -380,6 +380,19 @@ message CancelMuteGroupResp{
 
 
 
+message SetGroupMemberNicknameReq{
+  string groupID = 1;
+  string nickname = 2;
+  string opUserID = 3;
+  string operationID = 4;
+  string userID = 5;
+}
+message SetGroupMemberNicknameResp{
+  CommonResp CommonResp = 1;
+}
+
+
+
 
 service group{
   rpc createGroup(CreateGroupReq) returns(CreateGroupResp);
@@ -413,6 +426,9 @@ service group{
   rpc CancelMuteGroupMember(CancelMuteGroupMemberReq) returns(CancelMuteGroupMemberResp);
   rpc MuteGroup(MuteGroupReq) returns(MuteGroupResp);
   rpc CancelMuteGroup(CancelMuteGroupReq) returns(CancelMuteGroupResp);
+
+  rpc SetGroupMemberNickname(SetGroupMemberNicknameReq) returns (SetGroupMemberNicknameResp);
+
 }
 
 

pkg/proto/organization/organization.proto

@@ -28,13 +28,13 @@ message UpdateDepartmentResp{
 }
 
 
-message GetDepartmentReq{
+message GetSubDepartmentReq{
   string departmentID = 1;
   string operationID = 2;
   string opUserID = 3;
 }
 
-message GetDepartmentResp{
+message GetSubDepartmentResp{
   int32   errCode = 1;
   string  errMsg = 2;
   repeated server_api_params.Department departmentList = 3;
@@ -81,7 +81,7 @@ message UpdateOrganizationUserResp{
 
 
 message CreateDepartmentMemberReq{
-  server_api_params.UserInDepartment userInDepartment = 1;
+  server_api_params.DepartmentMember departmentMember = 1;
   string operationID = 2;
   string opUserID = 3;
 }
@@ -104,7 +104,7 @@ message GetUserInDepartmentResp{
 
 
 message UpdateUserInDepartmentReq{
-  server_api_params.UserInDepartment userInDepartment = 1;
+  server_api_params.DepartmentMember departmentMember = 1;
   string operationID = 2;
   string opUserID = 3;
 }
@@ -114,12 +114,23 @@ message UpdateUserInDepartmentResp{
 }
 
 
-message DeleteOrganizationReq{
+message DeleteUserInDepartmentReq{
+  string userID = 1;
+  string operationID = 2;
+  string opUserID = 3;
+  string departmentID = 4;
+}
+message DeleteUserInDepartmentResp{
+  int32   errCode = 1;
+  string  errMsg = 2;
+}
+
+message DeleteOrganizationUserReq{
   string userID = 1;
   string operationID = 2;
   string opUserID = 3;
 }
-message DeleteOrganizationResp{
+message DeleteOrganizationUserResp{
   int32   errCode = 1;
   string  errMsg = 2;
 }
@@ -134,21 +145,25 @@ message GetDepartmentMemberReq{
 message GetDepartmentMemberResp{
   int32   errCode = 1;
   string  errMsg = 2;
-  repeated  server_api_params.UserInDepartment userInDepartmentList = 3;
+  repeated  server_api_params.UserDepartmentMember userDepartmentMemberList = 3;
 }
 
 
 service organization{
-  rpc createDepartment(CreateDepartmentReq) returns(CreateDepartmentResp);
+  rpc CreateDepartment(CreateDepartmentReq) returns(CreateDepartmentResp);
   rpc UpdateDepartment(UpdateDepartmentReq) returns(UpdateDepartmentResp);
-  rpc GetDepartment(GetDepartmentReq) returns(GetDepartmentResp);
+  rpc GetSubDepartment(GetSubDepartmentReq) returns(GetSubDepartmentResp);
   rpc DeleteDepartment(DeleteDepartmentReq) returns(DeleteDepartmentResp);
+
   rpc CreateOrganizationUser(CreateOrganizationUserReq) returns(CreateOrganizationUserResp);
   rpc UpdateOrganizationUser(UpdateOrganizationUserReq) returns(UpdateOrganizationUserResp);
+  rpc DeleteOrganizationUser(DeleteOrganizationUserReq) returns(DeleteOrganizationUserResp);
+
+
   rpc CreateDepartmentMember(CreateDepartmentMemberReq) returns(CreateDepartmentMemberResp);
   rpc GetUserInDepartment(GetUserInDepartmentReq) returns(GetUserInDepartmentResp);
+  rpc DeleteUserInDepartment(DeleteUserInDepartmentReq) returns(DeleteUserInDepartmentResp);
   rpc UpdateUserInDepartment(UpdateUserInDepartmentReq) returns(UpdateUserInDepartmentResp);
-  rpc DeleteOrganization(DeleteOrganizationReq) returns(DeleteOrganizationResp);
   rpc GetDepartmentMember(GetDepartmentMemberReq) returns(GetDepartmentMemberResp);
 }
 

pkg/proto/sdk_ws/ws.proto

@@ -138,18 +138,23 @@ message OrganizationUser  {
 
 message DepartmentMember {
       string userID = 1;
-      string DepartmentID = 2;
+      string departmentID = 2;
-      int32 Order = 3;
+      int32 order = 3;
-      string Position = 4;
+      string position = 4;
-      int32 Leader = 5;
+      int32 leader = 5;
-      int32 Status = 6;
+      int32 status = 6;
-      string Ex     = 7;
+      string ex     = 7;
 }
 
 
+message  UserDepartmentMember {
+  OrganizationUser organizationUser = 1;
+  DepartmentMember departmentMember = 2;
+}
+
 
 message  UserInDepartment {
-  OrganizationUser departmentUser = 1;
+  OrganizationUser organizationUser = 1;
   repeated DepartmentMember departmentMemberList = 2;
 }
 
@@ -346,6 +351,12 @@ message GroupCancelMutedTips{
   int64 operationTime = 3;
 }
 
+message GroupMemberInfoSetTips{
+  GroupInfo group = 1;
+  GroupMemberFullInfo opUser = 2;
+  int64 operationTime = 3;
+  GroupMemberFullInfo changedUser = 4;
+}
 
 //////////////////////friend/////////////////////
 //message FriendInfo{

script/check_all.sh

@@ -20,6 +20,7 @@ service_port_name=(
   openImMessageCmsPort
   openImStatisticsPort
   openImOfficePort
+  openImOrganizationPort
 )
 switch=$(cat $config_path | grep demoswitch |awk -F '[:]' '{print $NF}')
 for i in ${service_port_name[*]}; do

script/path_info.cfg

@@ -48,7 +48,8 @@ service_source_root=(
   ../cmd/rpc/open_im_admin_cms/
   ../cmd/rpc/open_im_message_cms/
   ../cmd/rpc/open_im_statistics/
-  ../cmd/rpc/open_im_office/
+  ../cmd/rpc/open_im_office/ 
+  ../cmd/rpc/open_im_organization/
   ${msg_gateway_source_root}
   ${msg_transfer_source_root}
   ${msg_source_root}
@@ -70,6 +71,7 @@ service_names=(
   open_im_message_cms
   open_im_statistics
   open_im_office
+  open_im_organization	
   ${msg_gateway_name}
   ${msg_transfer_name}
   ${msg_name}

script/start_rpc_service.sh

@@ -19,6 +19,7 @@ service_filename=(
   open_im_statistics
   ${msg_name}
   open_im_office
+  open_im_organization
 )
 
 #service config port name
@@ -36,6 +37,7 @@ service_port_name=(
   openImStatisticsPort
   openImOfflineMessagePort
   openImOfficePort
+  openImOrganizationPort
 )
 
 for ((i = 0; i < ${#service_filename[*]}; i++)); do
@@ -64,4 +66,4 @@ for ((i = 0; i < ${#service_filename[*]}; i++)); do
     pid="netstat -ntlp|grep $j |awk '{printf \$7}'|cut -d/ -f1"
     echo -e "${GREEN_PREFIX}${service_filename[$i]} start success,port number:$j pid:$(eval $pid)$COLOR_SUFFIX"
   done
-done
+done