blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-23 09:50:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
# Conflicts:
#	pkg/common/constant/constant.go
This commit is contained in:
wangchuxiao 2022-04-18 19:26:26 +08:00
commit 3625befc0b
33 changed files with 3972 additions and 546 deletions

2
cmd/Open-IM-SDK-Core

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

31
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("/get_users_info", user.GetUsersInfo) //1
userRouterGroup.POST("/get_self_user_info", user.GetSelfUserInfo) //1
userRouterGroup.POST("/update_user_info", user.UpdateUserInfo) //1
userRouterGroup.POST("/get_users_info", user.GetUsersInfo) //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()

25
cmd/rpc/open_im_organization/Makefile Normal file

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

15
cmd/rpc/open_im_organization/main.go Normal file

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

16
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:

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

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

439
internal/api/organization/organization.go Normal file

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

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

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

86
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) {
log.NewError(req.OperationID, "IsMangerUserID IsGroupOwnerAdmin false ", req.GroupID, req.OpUserID)
if !token_verify.IsManagerUserID(req.OpUserID) && !imdb.IsGroupOwnerAdmin(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
}

23
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{}}

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

12
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) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
if !token_verify.IsManagerUserID(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) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
if !token_verify.IsManagerUserID(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) {
log.NewError(req.OperationID, "IsMangerUserID false ", req.OpUserID)
if !token_verify.IsManagerUserID(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)

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

110
pkg/base_info/organization_api_struct.go Normal file

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

6
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 {

7
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
WorkMomentNewCommentNotification = 1801
OrganizationChangedNotification = 1801
WorkMomentNotificationStart = 1900
WorkMomentNewCommentNotification = 1901
NotificationEnd = 2000

4
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")

23
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"`
Order int32 `gorm:"column:order" json:"order" `
DepartmentType int32 `gorm:"column:department_type" json:"departmentType"`
ParentID string `gorm:"column:parent_id;size:64" json:"parentID" binding:"required"` // "0" or Real parent id
Order int32 `gorm:"column:order" json:"order" ` // 1, 2, ...
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"`
DepartmentID string `gorm:"column:department_id;primary_key;size:64"`
Order int32 `gorm:"column:order" json:"order"`
Position string `gorm:"column:position;size:256" json:"position"`
Leader int32 `gorm:"column:leader" json:"leader"`
Status int32 `gorm:"column:status" json:"status"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
UserID string `gorm:"column:user_id;primary_key;size:64"`
DepartmentID string `gorm:"column:department_id;primary_key;size:64"`
Order int32 `gorm:"column:order" json:"order"` //1,2
Position string `gorm:"column:position;size:256" json:"position"`
Leader int32 `gorm:"column:leader" json:"leader"` //-1, 1
Status int32 `gorm:"column:status" json:"status"` //-1, 1
CreateTime time.Time `gorm:"column:create_time"`
Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"`
}
func (DepartmentMember) TableName() string {

28
pkg/common/db/mysql.go

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

189
pkg/common/db/mysql_model/im_mysql_model/organization_model.go Normal file

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

26
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) {

2
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, "")

539
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{
// 2068 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4f, 0x6f, 0xdb, 0xc8,
0x15, 0x07, 0xed, 0xc8, 0xb6, 0x9e, 0xad, 0xc8, 0x1e, 0x47, 0xb6, 0xc2, 0xf5, 0x66, 0xbd, 0xb3,
0xe9, 0x22, 0xe8, 0x1f, 0x1b, 0xcd, 0x02, 0x39, 0x74, 0x8b, 0xa6, 0xf1, 0x9f, 0xc4, 0x4a, 0x22,
0xbb, 0xa1, 0xd3, 0x4b, 0x2e, 0xa9, 0x56, 0x1c, 0x0b, 0xaa, 0x25, 0x92, 0xe6, 0x50, 0x4e, 0xdb,
0xcb, 0xa2, 0x97, 0x05, 0xb6, 0xed, 0xa1, 0x45, 0x81, 0x3d, 0x15, 0x68, 0x73, 0xeb, 0xa1, 0x87,
0x1e, 0xda, 0x73, 0xd1, 0x8f, 0xd1, 0x4f, 0xd1, 0xaf, 0x50, 0x70, 0x66, 0x38, 0x1c, 0x0e, 0x87,
0xb4, 0x42, 0x25, 0xcd, 0x45, 0xc0, 0xbc, 0x79, 0xc3, 0xf7, 0x7b, 0x6f, 0xe6, 0xbd, 0x79, 0xef,
0x8d, 0x60, 0x6d, 0x10, 0xfa, 0x93, 0x60, 0x97, 0xfd, 0xee, 0x04, 0xa1, 0x1f, 0xf9, 0xa8, 0xc6,
0x06, 0xf6, 0xc7, 0x27, 0x01, 0xf1, 0x5e, 0x76, 0xba, 0xbb, 0xc1, 0xf9, 0x60, 0x97, 0xcd, 0xec,
0x52, 0xf7, 0xfc, 0xe5, 0x2b, 0xba, 0xfb, 0x8a, 0x72, 0x4e, 0xfc, 0x23, 0x80, 0x7d, 0x7f, 0x3c,
0xf6, 0x3d, 0x87, 0xd0, 0x00, 0xb5, 0x61, 0xf1, 0x30, 0x0c, 0xf7, 0x7d, 0x97, 0xb4, 0xad, 0x6d,
0xeb, 0x4e, 0xcd, 0x49, 0x86, 0x68, 0x03, 0x16, 0x0e, 0xc3, 0xb0, 0x4b, 0x07, 0xed, 0xb9, 0x6d,
0xeb, 0x4e, 0xdd, 0x11, 0x23, 0xfc, 0x18, 0xd0, 0xa3, 0x58, 0xd6, 0x03, 0xd7, 0xed, 0x92, 0xf1,
0x17, 0x24, 0xec, 0x78, 0x67, 0x7e, 0xcc, 0xfd, 0x53, 0x4a, 0xc2, 0xce, 0x01, 0xfb, 0x4c, 0xdd,
0x11, 0x23, 0xb4, 0x05, 0x75, 0xc7, 0x1f, 0x91, 0xa7, 0xe4, 0x92, 0x8c, 0xd8, 0x87, 0x6a, 0x4e,
0x4a, 0xc0, 0xff, 0xb5, 0xe0, 0xfa, 0x7e, 0x48, 0x7a, 0x11, 0x61, 0x9f, 0x74, 0xc8, 0x05, 0x7a,
0x00, 0xd7, 0x3b, 0xde, 0x30, 0xe2, 0x9f, 0x7e, 0x3a, 0xa4, 0x51, 0xdb, 0xda, 0x9e, 0xbf, 0xb3,
0x7c, 0xf7, 0xe6, 0x0e, 0x57, 0x37, 0x2f, 0xdb, 0xd1, 0x16, 0xa0, 0x1f, 0x40, 0x9d, 0x71, 0xc5,
0x93, 0x4c, 0xe6, 0xf2, 0xdd, 0xad, 0x1d, 0x4a, 0xc2, 0x4b, 0x12, 0xbe, 0xec, 0x05, 0xc3, 0x97,
0x41, 0x2f, 0xec, 0x8d, 0xe9, 0x8e, 0xe4, 0x71, 0x52, 0x76, 0xb4, 0x0d, 0xcb, 0x27, 0x01, 0x09,
0x7b, 0xd1, 0xd0, 0xf7, 0x3a, 0x07, 0xed, 0x79, 0xa6, 0x8c, 0x4a, 0x42, 0x36, 0x2c, 0x9d, 0x04,
0x42, 0xd7, 0x6b, 0x6c, 0x5a, 0x8e, 0xd9, 0xea, 0x57, 0x1e, 0x09, 0xc5, 0x74, 0x4d, 0xac, 0x4e,
0x49, 0xf8, 0x4b, 0x68, 0x66, 0x14, 0xae, 0xb2, 0x05, 0x59, 0x05, 0xe7, 0xdf, 0x48, 0x41, 0x1c,
0xc2, 0xea, 0x23, 0x12, 0xb1, 0x31, 0x65, 0x73, 0xe4, 0x22, 0x86, 0xcd, 0x19, 0x0e, 0xa4, 0xc1,
0xeb, 0x8e, 0x4a, 0xd2, 0xcd, 0x32, 0x57, 0x6e, 0x96, 0xf9, 0xac, 0x59, 0xf0, 0xd7, 0x16, 0xac,
0x69, 0x42, 0x2b, 0xe9, 0xbd, 0x07, 0x0d, 0xa9, 0x08, 0x43, 0x3a, 0xcf, 0x8e, 0x46, 0xb9, 0xee,
0xd9, 0x25, 0xf8, 0xb7, 0x16, 0x34, 0x4f, 0x05, 0x96, 0x44, 0xff, 0x8c, 0x3d, 0xad, 0x37, 0x3b,
0x30, 0xaa, 0xde, 0x73, 0x86, 0xe3, 0x50, 0x7a, 0x98, 0xf0, 0x21, 0xac, 0x66, 0xc1, 0xd0, 0x00,
0x7d, 0x5f, 0x75, 0x50, 0x01, 0x67, 0x4d, 0x9c, 0xfe, 0x74, 0xc2, 0x51, 0x98, 0xf0, 0xaf, 0xc0,
0x4e, 0xec, 0xfb, 0x20, 0x08, 0x46, 0xc3, 0x3e, 0xfb, 0x7e, 0xac, 0x6f, 0xac, 0x9e, 0x0a, 0xd1,
0x2a, 0x87, 0x68, 0xd8, 0xd8, 0x5b, 0x00, 0x0f, 0x43, 0x7f, 0x9c, 0xd9, 0x5a, 0x85, 0x82, 0xff,
0x64, 0xc1, 0x07, 0x85, 0xc2, 0x2b, 0x6d, 0xf3, 0x13, 0x58, 0x4d, 0xc2, 0xc1, 0x84, 0xd0, 0x48,
0xd9, 0xe9, 0x8f, 0x8a, 0x76, 0x45, 0xb0, 0x3a, 0xb9, 0x85, 0x38, 0x82, 0xad, 0x47, 0x24, 0x8a,
0xb1, 0x3a, 0xe4, 0xc2, 0x60, 0x9c, 0xa2, 0xc0, 0x35, 0xdb, 0xbe, 0xfe, 0xd9, 0x82, 0x0f, 0x4b,
0xc4, 0x56, 0xda, 0x65, 0xa3, 0x5d, 0xe6, 0xaa, 0xda, 0xe5, 0x5f, 0x16, 0xb4, 0x9e, 0x87, 0x3d,
0x8f, 0x9e, 0x91, 0x90, 0x4d, 0xb2, 0x28, 0x15, 0x5b, 0xa4, 0x0d, 0x8b, 0xc2, 0xf5, 0x85, 0x49,
0x92, 0x21, 0xfa, 0x14, 0xae, 0x9f, 0x8c, 0x5c, 0x35, 0xc2, 0x71, 0xcb, 0x68, 0xd4, 0x98, 0xef,
0x98, 0xbc, 0x52, 0xf9, 0xb8, 0x89, 0x34, 0xaa, 0x6e, 0xc7, 0x6b, 0xe5, 0x51, 0xa5, 0xa6, 0x45,
0x95, 0x27, 0xb0, 0x61, 0x52, 0xa0, 0x9a, 0x07, 0x7d, 0x65, 0xc1, 0xca, 0x63, 0x7f, 0xe8, 0xc9,
0x7b, 0xa8, 0xd8, 0x0a, 0xb7, 0x00, 0x1c, 0x72, 0xd1, 0x25, 0x94, 0xf6, 0x06, 0x44, 0x58, 0x40,
0xa1, 0x94, 0x45, 0xc2, 0xab, 0x35, 0xc6, 0x7b, 0xd0, 0x50, 0x70, 0x54, 0x53, 0xe6, 0x3f, 0xb1,
0x4b, 0x6a, 0xfe, 0x18, 0x4f, 0xf8, 0x1e, 0x25, 0x22, 0xde, 0xab, 0x28, 0xac, 0x72, 0xbb, 0xeb,
0xa7, 0x5f, 0xb1, 0xcc, 0x7c, 0xce, 0x32, 0x4a, 0xa8, 0xb8, 0xa6, 0x87, 0x8a, 0x78, 0xfe, 0xa8,
0xe7, 0xb9, 0x23, 0xe2, 0xc6, 0x4e, 0xcf, 0xf7, 0x53, 0xa1, 0x20, 0x0c, 0x2b, 0x7c, 0xe4, 0x10,
0x3a, 0x19, 0x45, 0xed, 0x05, 0x16, 0x2f, 0x32, 0x34, 0xfc, 0x0c, 0xb6, 0x8a, 0x55, 0xab, 0x66,
0xae, 0x33, 0x58, 0x79, 0x36, 0x19, 0x46, 0x53, 0x6c, 0xfd, 0x6c, 0xd7, 0xe0, 0x1e, 0x34, 0x14,
0x39, 0xd5, 0xb0, 0xbe, 0xb6, 0xa0, 0x95, 0x44, 0xdb, 0x34, 0xe5, 0x29, 0x47, 0x3d, 0x53, 0x28,
0x8b, 0x03, 0xe4, 0xc3, 0xe1, 0x28, 0x22, 0x21, 0xdb, 0xd0, 0x9a, 0x23, 0x46, 0xb1, 0xbc, 0x63,
0xf2, 0x8b, 0xe8, 0x94, 0x5c, 0xb0, 0x9d, 0xac, 0x39, 0xc9, 0x10, 0xff, 0xcd, 0x82, 0x0d, 0x13,
0xc6, 0x4a, 0x97, 0xc1, 0x43, 0x80, 0x71, 0x9a, 0x0b, 0xf2, 0x6b, 0xe0, 0xd3, 0xa2, 0x70, 0xc7,
0xa5, 0x3d, 0x9c, 0x8c, 0x46, 0xec, 0x36, 0x55, 0x56, 0xc6, 0x92, 0x3d, 0x01, 0x97, 0xeb, 0x91,
0x0c, 0xf1, 0xef, 0x73, 0x70, 0x65, 0x62, 0x54, 0x1a, 0x04, 0x14, 0x58, 0x73, 0x2c, 0x63, 0x52,
0xc5, 0xcd, 0x16, 0x04, 0xfe, 0x68, 0xc1, 0xa6, 0x11, 0xd2, 0xfb, 0x34, 0x21, 0xfe, 0xbb, 0x05,
0xe8, 0xc9, 0xb0, 0x7f, 0xae, 0xf0, 0x95, 0x1b, 0xe9, 0xdb, 0xb0, 0x1a, 0xf3, 0x13, 0x97, 0x2b,
0xae, 0x98, 0x2a, 0x47, 0x8f, 0xc1, 0x3b, 0xa4, 0x47, 0x7d, 0x4f, 0x98, 0x4b, 0x8c, 0x74, 0x63,
0xd5, 0xca, 0x5d, 0x6e, 0x41, 0x73, 0xb9, 0xcf, 0xa1, 0xde, 0x71, 0xef, 0xf2, 0xd0, 0x51, 0x78,
0xd5, 0x33, 0xd1, 0x2c, 0xe0, 0xf0, 0x02, 0x45, 0x8c, 0xf0, 0x97, 0xb0, 0x9e, 0x53, 0xb7, 0xd2,
0x06, 0xdc, 0x83, 0x86, 0x44, 0xa1, 0xec, 0xc1, 0xaa, 0x70, 0x75, 0x39, 0xe7, 0x64, 0xd9, 0xf0,
0x84, 0xf9, 0x7a, 0x7c, 0x1d, 0x10, 0x97, 0xa1, 0x48, 0x7c, 0x3d, 0x1b, 0x68, 0xad, 0x5c, 0xa0,
0xdd, 0x86, 0x65, 0x3f, 0x1f, 0xa7, 0xfc, 0x29, 0xe3, 0xd4, 0x57, 0xdc, 0x21, 0x72, 0x72, 0x67,
0xaa, 0x55, 0xa6, 0xce, 0xd7, 0x53, 0x76, 0xfc, 0x0f, 0x0b, 0x6e, 0x74, 0xbc, 0xcb, 0x61, 0x44,
0x62, 0x64, 0xcf, 0x7d, 0x19, 0xa1, 0xaf, 0x8e, 0xc3, 0xc5, 0x97, 0x54, 0x7a, 0xd0, 0xae, 0x65,
0x0e, 0xda, 0x77, 0x61, 0x8d, 0xcb, 0x52, 0x4f, 0x6b, 0x8d, 0x9d, 0xd6, 0xfc, 0x44, 0xe9, 0xa1,
0xfb, 0xb5, 0x05, 0x2d, 0x03, 0xec, 0xff, 0xeb, 0xd1, 0xf1, 0xe0, 0x86, 0x4c, 0xca, 0x47, 0xa3,
0x69, 0x9c, 0x75, 0xb6, 0x84, 0xf7, 0x0f, 0xca, 0xbd, 0xa4, 0x08, 0x7c, 0xaf, 0xf1, 0xea, 0x1b,
0x0b, 0x96, 0xf6, 0xbb, 0xa7, 0x8c, 0x6d, 0xa6, 0x1a, 0xef, 0x0e, 0x34, 0xb9, 0xac, 0x1e, 0x8d,
0x48, 0x78, 0xdc, 0x1b, 0x27, 0x69, 0x9f, 0x4e, 0x46, 0xb7, 0x45, 0x85, 0xca, 0x49, 0x1d, 0x57,
0x98, 0x2a, 0x4b, 0x8c, 0xc3, 0xfb, 0x72, 0x62, 0xac, 0x78, 0x53, 0xb6, 0x04, 0x36, 0xf6, 0x65,
0xbe, 0x2d, 0x29, 0x01, 0x1d, 0x00, 0xfc, 0xa4, 0x37, 0x18, 0x7a, 0xcc, 0xd4, 0xa2, 0x9f, 0x71,
0xdb, 0x00, 0x5d, 0x64, 0xf7, 0x29, 0xaf, 0xa3, 0xac, 0x9b, 0x62, 0x0b, 0x5f, 0x5b, 0xb0, 0x92,
0xa2, 0xa2, 0x01, 0xfa, 0x1e, 0xd4, 0x13, 0xf3, 0x51, 0xd1, 0x85, 0x69, 0x26, 0xd9, 0x89, 0xa0,
0x3b, 0x29, 0xc7, 0x5b, 0xc2, 0x29, 0x6d, 0x31, 0x19, 0x53, 0x86, 0xb2, 0xe6, 0xa4, 0x04, 0x7c,
0x99, 0x42, 0xa4, 0xb1, 0xe5, 0xb2, 0x32, 0xad, 0xb7, 0x63, 0x9b, 0x7c, 0x38, 0xc1, 0x7f, 0xb1,
0xa0, 0xa1, 0x08, 0x7e, 0x5f, 0xc6, 0xb1, 0x61, 0x29, 0xb1, 0x85, 0xb0, 0x8d, 0x1c, 0xe3, 0x93,
0xb4, 0xc7, 0x62, 0x70, 0x77, 0x37, 0xeb, 0xee, 0xee, 0x14, 0x3a, 0x9f, 0x43, 0x8b, 0x0f, 0x79,
0xaf, 0xea, 0x34, 0xea, 0x45, 0x13, 0x5a, 0xfe, 0xd1, 0x0d, 0x58, 0xe0, 0x6c, 0xc9, 0x4d, 0xca,
0x47, 0x53, 0x1c, 0xbe, 0x36, 0x6c, 0x98, 0x84, 0xf1, 0xca, 0x0c, 0x89, 0x29, 0x56, 0x4e, 0xfb,
0x23, 0x72, 0x25, 0x08, 0x16, 0xb6, 0xdc, 0x24, 0xac, 0xf0, 0x51, 0xb6, 0x15, 0x39, 0xaf, 0xb5,
0x22, 0xa7, 0x48, 0xca, 0x5a, 0xb0, 0x9e, 0xc3, 0x41, 0x03, 0xfc, 0x14, 0xae, 0x1f, 0x90, 0x11,
0x51, 0x5a, 0x98, 0xb3, 0x18, 0x7d, 0x0d, 0x9a, 0x99, 0xaf, 0xd1, 0x00, 0x77, 0xa1, 0x99, 0x6c,
0xec, 0xde, 0x2f, 0x3b, 0xee, 0xac, 0x12, 0xee, 0xa7, 0x0d, 0x40, 0xfe, 0x39, 0x1a, 0xa0, 0xef,
0xa4, 0x81, 0x52, 0x38, 0x51, 0xee, 0x2c, 0x4b, 0x06, 0xfc, 0xcf, 0x5c, 0x09, 0x42, 0xf7, 0xbb,
0xa7, 0xe5, 0xb0, 0x6c, 0x58, 0x8a, 0x8d, 0xa6, 0x84, 0x4e, 0x39, 0xd6, 0x5c, 0x63, 0xfe, 0xed,
0xf8, 0xb0, 0x61, 0xff, 0xfe, 0x9d, 0xcf, 0xf3, 0x19, 0x6e, 0x1a, 0xa0, 0x1f, 0xc3, 0x22, 0xbf,
0x37, 0x12, 0x57, 0x9e, 0xf6, 0xba, 0x49, 0x96, 0xa1, 0x43, 0x83, 0x7f, 0x7f, 0xcb, 0xa8, 0x04,
0xaf, 0x55, 0x0b, 0xb4, 0xb8, 0x05, 0xc0, 0x25, 0x28, 0xe1, 0x4f, 0xa1, 0xe0, 0xdf, 0x59, 0xd0,
0x76, 0xc8, 0xd8, 0xbf, 0x24, 0x6f, 0x64, 0xfe, 0x36, 0x2c, 0x72, 0x27, 0xa0, 0x22, 0xff, 0x4e,
0x86, 0x6f, 0xd4, 0xef, 0x76, 0xb5, 0x7e, 0xb7, 0x8b, 0xbb, 0x70, 0xb3, 0x00, 0x0d, 0xbf, 0xf8,
0xe9, 0xa4, 0xdf, 0x27, 0x94, 0x8a, 0x8e, 0x72, 0x32, 0x8c, 0x3d, 0xf4, 0xac, 0x37, 0x1c, 0x11,
0x57, 0xa0, 0x11, 0x23, 0xfc, 0xb5, 0x05, 0xad, 0x07, 0xae, 0xfb, 0x2e, 0x54, 0x73, 0xf3, 0xaa,
0xb9, 0xa5, 0xaa, 0x3d, 0x86, 0x0d, 0x13, 0x94, 0x4a, 0x7a, 0x0d, 0xa1, 0x79, 0x30, 0xa4, 0xe3,
0x21, 0xa5, 0x32, 0x46, 0xd8, 0xb0, 0xe4, 0x6b, 0x3d, 0x59, 0x3f, 0x98, 0x3a, 0x7b, 0x6f, 0xc3,
0xe2, 0x20, 0x9b, 0xdd, 0x8a, 0x21, 0x3e, 0x84, 0xd5, 0xac, 0x28, 0xde, 0x66, 0xe8, 0x4f, 0xd3,
0x66, 0x48, 0x99, 0xf0, 0x5f, 0x2d, 0x40, 0xdd, 0x49, 0x44, 0xb4, 0xeb, 0xe4, 0x1d, 0xa1, 0x8e,
0x0d, 0x37, 0x51, 0x9b, 0x46, 0x62, 0x84, 0x30, 0xac, 0x8c, 0x27, 0x11, 0x71, 0x4f, 0x49, 0xdf,
0xf7, 0x5c, 0xca, 0xaa, 0xbf, 0x86, 0x93, 0xa1, 0xe1, 0x23, 0x58, 0xcf, 0x21, 0xad, 0xa6, 0xf4,
0x6f, 0x2c, 0x68, 0xef, 0xf7, 0xbc, 0x3e, 0x19, 0xbd, 0x7f, 0xd5, 0xf1, 0x31, 0xdc, 0x2c, 0xc0,
0x52, 0x4d, 0xb9, 0x33, 0x58, 0x91, 0x5f, 0x7a, 0x97, 0x07, 0x70, 0x0f, 0x1a, 0x8a, 0x9c, 0x6a,
0x58, 0x47, 0x80, 0x34, 0xdd, 0xdf, 0x25, 0xe2, 0x23, 0x58, 0xcf, 0x49, 0xab, 0x84, 0xfb, 0xee,
0x37, 0x6b, 0xc0, 0xdf, 0x61, 0xd1, 0x0f, 0x61, 0xb9, 0x9f, 0x3e, 0xf3, 0xa1, 0x56, 0xb2, 0x2e,
0xf3, 0xd6, 0x69, 0x6f, 0x98, 0xc8, 0x34, 0x40, 0xf7, 0xa0, 0xfe, 0xf3, 0xa4, 0x07, 0x8c, 0xd6,
0x05, 0x93, 0xda, 0x9d, 0xb6, 0x6f, 0xe4, 0x89, 0x7c, 0xdd, 0x45, 0xd2, 0x60, 0x94, 0xeb, 0xd4,
0xd6, 0xa6, 0x5c, 0x97, 0xed, 0x43, 0xee, 0x41, 0x63, 0xa0, 0x3e, 0xcf, 0xa1, 0xcd, 0xe4, 0xb1,
0x55, 0x7b, 0x29, 0xb4, 0xdb, 0xe6, 0x09, 0x1a, 0xa0, 0xfb, 0xb0, 0x42, 0x95, 0x97, 0x2c, 0x94,
0xe8, 0xa6, 0xbd, 0xb5, 0xd9, 0x9b, 0x46, 0x3a, 0x0d, 0xd0, 0xcf, 0x60, 0x73, 0x60, 0x7e, 0x46,
0x42, 0x1f, 0x6b, 0x52, 0xf3, 0xcf, 0x38, 0x36, 0xbe, 0x8a, 0x85, 0x06, 0xe8, 0x0c, 0x6e, 0x0e,
0x8a, 0xde, 0x64, 0xd0, 0x27, 0xe9, 0x07, 0x0a, 0x1f, 0x8b, 0xec, 0xdb, 0x57, 0x33, 0xd1, 0x00,
0x3d, 0x03, 0x14, 0xe5, 0x1e, 0x26, 0xd0, 0x96, 0x58, 0x6b, 0x7c, 0x74, 0xb1, 0x3f, 0x2c, 0x99,
0xa5, 0x01, 0xea, 0x43, 0x7b, 0x50, 0xd0, 0xf5, 0x46, 0x38, 0xf3, 0x32, 0x6e, 0xec, 0xf8, 0xdb,
0x9f, 0x5c, 0xc9, 0xc3, 0x71, 0x0f, 0x72, 0x6d, 0x5b, 0x89, 0xdb, 0xd8, 0x75, 0x96, 0xb8, 0x0b,
0xfa, 0xbd, 0xcf, 0x61, 0x7d, 0x90, 0xef, 0x63, 0x22, 0xf3, 0x2a, 0x79, 0xca, 0x6e, 0x95, 0x4d,
0xd3, 0x00, 0x1d, 0x41, 0xf3, 0x3c, 0xdb, 0x98, 0x43, 0xc9, 0xdf, 0x03, 0xf2, 0xfd, 0x49, 0xdb,
0x2e, 0x9a, 0x92, 0x2a, 0x6b, 0x9d, 0x2e, 0x55, 0xe5, 0x7c, 0xf3, 0x4d, 0x55, 0xd9, 0xd4, 0x22,
0x3b, 0x86, 0xb5, 0xa1, 0xde, 0xfc, 0x41, 0x1f, 0x24, 0xfd, 0x1a, 0x43, 0x37, 0xcb, 0xde, 0x2a,
0x9e, 0xe4, 0xdf, 0x1b, 0xe8, 0x8d, 0x15, 0xf9, 0x3d, 0x53, 0x8f, 0xc7, 0xde, 0x2a, 0x9e, 0xe4,
0x8e, 0xaa, 0xe6, 0xff, 0xd2, 0x51, 0xb5, 0x1a, 0xc3, 0xde, 0x34, 0xd2, 0x69, 0x80, 0x3e, 0x83,
0xa5, 0x84, 0x86, 0x90, 0xc6, 0x14, 0x2f, 0x5c, 0xcf, 0xd1, 0x78, 0x68, 0x92, 0x31, 0x03, 0xe9,
0x1c, 0x54, 0x0d, 0x4d, 0xd9, 0x32, 0xfb, 0x99, 0x2c, 0xfe, 0x94, 0xba, 0x50, 0x6e, 0x90, 0xb1,
0x3e, 0x95, 0x1b, 0x64, 0x2e, 0x28, 0xe3, 0xd3, 0xa3, 0xd5, 0x71, 0xf2, 0xf4, 0xe4, 0xeb, 0x4c,
0x79, 0x7a, 0x0c, 0xa5, 0x5f, 0x1c, 0xe5, 0x95, 0x62, 0x4d, 0x46, 0xf9, 0x6c, 0x39, 0x28, 0xa3,
0xbc, 0x56, 0xd7, 0xc5, 0xaa, 0xe5, 0xcb, 0x91, 0x02, 0x77, 0x13, 0x79, 0x70, 0x81, 0xbb, 0xc9,
0xd4, 0xf4, 0x05, 0xb4, 0x8c, 0xf9, 0x38, 0xfa, 0x48, 0xac, 0x2b, 0xaa, 0x1d, 0xec, 0xed, 0x72,
0x06, 0x0e, 0x37, 0x9f, 0x10, 0x4b, 0xb8, 0xc6, 0xb4, 0x5d, 0xc2, 0x2d, 0xc8, 0xa4, 0xef, 0xc3,
0x8a, 0x9a, 0xac, 0xca, 0xa3, 0xa8, 0x25, 0xcb, 0xf2, 0x28, 0xe6, 0x32, 0xdb, 0x23, 0x68, 0x6a,
0xe9, 0x91, 0xdc, 0xca, 0x7c, 0x0a, 0x27, 0xb7, 0xd2, 0x94, 0x51, 0xbd, 0x80, 0x96, 0x31, 0xdd,
0x92, 0x96, 0x2b, 0x4a, 0x0c, 0xa5, 0xe5, 0x8a, 0xb3, 0xb5, 0x7b, 0x50, 0x97, 0x64, 0x79, 0xf6,
0xd5, 0xd4, 0x46, 0x9e, 0xfd, 0x6c, 0x06, 0x72, 0x04, 0x4d, 0xed, 0xa3, 0x52, 0xbb, 0x7c, 0x7a,
0x24, 0xb5, 0x33, 0xe4, 0x32, 0x7b, 0xcd, 0x17, 0x8d, 0x1d, 0xfe, 0x77, 0xb1, 0xcf, 0xd9, 0xef,
0x17, 0x0b, 0xec, 0xbf, 0x60, 0x9f, 0xfd, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x2b, 0x24, 0xa7,
0x4a, 0x26, 0x00, 0x00,
var fileDescriptor_group_95c16320d90511af = []byte{
// 2138 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x1a, 0x4d, 0x6f, 0x1c, 0x49,
0x55, 0xed, 0xf1, 0xd8, 0x9e, 0x67, 0x4f, 0xc6, 0x2e, 0xef, 0xd8, 0xe3, 0x5e, 0x6f, 0xd6, 0xa9,
0x0d, 0xab, 0x88, 0x0f, 0x5b, 0x64, 0xa5, 0x1c, 0x58, 0x44, 0x88, 0x3f, 0x12, 0x4f, 0x92, 0xb1,
0x49, 0x3b, 0x5c, 0x22, 0xa1, 0x30, 0x3b, 0x5d, 0x1e, 0x0d, 0x9e, 0xe9, 0x6e, 0x77, 0xf5, 0x38,
0xc0, 0x65, 0xc5, 0x65, 0xa5, 0x05, 0x0e, 0x20, 0x24, 0x4e, 0x48, 0xb0, 0x27, 0x38, 0x70, 0xe0,
0x00, 0x67, 0xc4, 0xcf, 0xe0, 0x57, 0x70, 0xe2, 0x8e, 0xba, 0xaa, 0xba, 0xba, 0xba, 0xab, 0xba,
0x3d, 0x99, 0x49, 0xc8, 0x65, 0xa4, 0xf7, 0xea, 0x55, 0xbf, 0x8f, 0x7a, 0xef, 0xd5, 0x7b, 0xaf,
0x06, 0xd6, 0xfa, 0xa1, 0x3f, 0x0e, 0xf6, 0xd8, 0xef, 0x6e, 0x10, 0xfa, 0x91, 0x8f, 0xaa, 0x0c,
0xb0, 0x6f, 0x9d, 0x06, 0xc4, 0x7b, 0xd9, 0xee, 0xec, 0x05, 0x17, 0xfd, 0x3d, 0xb6, 0xb2, 0x47,
0xdd, 0x8b, 0x97, 0xaf, 0xe8, 0xde, 0x2b, 0xca, 0x29, 0xf1, 0xf7, 0x00, 0x0e, 0xfc, 0xd1, 0xc8,
0xf7, 0x1c, 0x42, 0x03, 0xd4, 0x82, 0xc5, 0xa3, 0x30, 0x3c, 0xf0, 0x5d, 0xd2, 0xb2, 0x76, 0xac,
0x3b, 0x55, 0x27, 0x01, 0xd1, 0x06, 0x2c, 0x1c, 0x85, 0x61, 0x87, 0xf6, 0x5b, 0x73, 0x3b, 0xd6,
0x9d, 0x9a, 0x23, 0x20, 0xfc, 0x18, 0xd0, 0xa3, 0x98, 0xd7, 0x03, 0xd7, 0xed, 0x90, 0xd1, 0x67,
0x24, 0x6c, 0x7b, 0xe7, 0x7e, 0x4c, 0xfd, 0x43, 0x4a, 0xc2, 0xf6, 0x21, 0xfb, 0x4c, 0xcd, 0x11,
0x10, 0xda, 0x86, 0x9a, 0xe3, 0x0f, 0xc9, 0x53, 0x72, 0x45, 0x86, 0xec, 0x43, 0x55, 0x27, 0x45,
0xe0, 0xff, 0x58, 0x70, 0xe3, 0x20, 0x24, 0xdd, 0x88, 0xb0, 0x4f, 0x3a, 0xe4, 0x12, 0x3d, 0x80,
0x1b, 0x6d, 0x6f, 0x10, 0xf1, 0x4f, 0x3f, 0x1d, 0xd0, 0xa8, 0x65, 0xed, 0x54, 0xee, 0x2c, 0xdf,
0xdd, 0xda, 0xe5, 0xea, 0xea, 0xbc, 0x9d, 0xdc, 0x06, 0xf4, 0x1d, 0xa8, 0x31, 0xaa, 0x78, 0x91,
0xf1, 0x5c, 0xbe, 0xbb, 0xbd, 0x4b, 0x49, 0x78, 0x45, 0xc2, 0x97, 0xdd, 0x60, 0xf0, 0x32, 0xe8,
0x86, 0xdd, 0x11, 0xdd, 0x95, 0x34, 0x4e, 0x4a, 0x8e, 0x76, 0x60, 0xf9, 0x34, 0x20, 0x61, 0x37,
0x1a, 0xf8, 0x5e, 0xfb, 0xb0, 0x55, 0x61, 0xca, 0xa8, 0x28, 0x64, 0xc3, 0xd2, 0x69, 0x20, 0x74,
0x9d, 0x67, 0xcb, 0x12, 0x66, 0xbb, 0x5f, 0x79, 0x24, 0x14, 0xcb, 0x55, 0xb1, 0x3b, 0x45, 0xe1,
0xcf, 0xa1, 0x91, 0x51, 0x78, 0x9a, 0x23, 0xc8, 0x2a, 0x58, 0x79, 0x2d, 0x05, 0x71, 0x08, 0xab,
0x8f, 0x48, 0xc4, 0x60, 0xca, 0xd6, 0xc8, 0x65, 0x2c, 0x36, 0x27, 0x38, 0x94, 0x06, 0xaf, 0x39,
0x2a, 0x2a, 0x6f, 0x96, 0xb9, 0x72, 0xb3, 0x54, 0xb2, 0x66, 0xc1, 0x5f, 0x5a, 0xb0, 0x96, 0x63,
0x3a, 0x95, 0xde, 0xfb, 0x50, 0x97, 0x8a, 0x30, 0x49, 0x2b, 0xcc, 0x35, 0xca, 0x75, 0xcf, 0x6e,
0xc1, 0xbf, 0xb2, 0xa0, 0x71, 0x26, 0x64, 0x49, 0xf4, 0xcf, 0xd8, 0xd3, 0x7a, 0x3d, 0x87, 0x51,
0xf5, 0x9e, 0x33, 0xb8, 0x43, 0xa9, 0x33, 0xe1, 0x23, 0x58, 0xcd, 0x0a, 0x43, 0x03, 0xf4, 0x6d,
0x35, 0x40, 0x85, 0x38, 0x6b, 0xc2, 0xfb, 0xd3, 0x05, 0x47, 0x21, 0xc2, 0x3f, 0x07, 0x3b, 0xb1,
0xef, 0x83, 0x20, 0x18, 0x0e, 0x7a, 0xec, 0xfb, 0xb1, 0xbe, 0xb1, 0x7a, 0xaa, 0x88, 0x56, 0xb9,
0x88, 0x86, 0x83, 0xbd, 0x09, 0xf0, 0x30, 0xf4, 0x47, 0x99, 0xa3, 0x55, 0x30, 0xf8, 0x0f, 0x16,
0xbc, 0x5f, 0xc8, 0x7c, 0xaa, 0x63, 0x7e, 0x02, 0xab, 0x49, 0x3a, 0x18, 0x13, 0x1a, 0x29, 0x27,
0xfd, 0x61, 0xd1, 0xa9, 0x08, 0x52, 0x47, 0xdb, 0x88, 0x23, 0xd8, 0x7e, 0x44, 0xa2, 0x58, 0x56,
0x87, 0x5c, 0x1a, 0x8c, 0x53, 0x94, 0xb8, 0x66, 0x3b, 0xd7, 0x3f, 0x5a, 0xf0, 0x41, 0x09, 0xdb,
0xa9, 0x4e, 0xd9, 0x68, 0x97, 0xb9, 0x69, 0xed, 0xf2, 0x4f, 0x0b, 0x9a, 0xcf, 0xc3, 0xae, 0x47,
0xcf, 0x49, 0xc8, 0x16, 0x59, 0x96, 0x8a, 0x2d, 0xd2, 0x82, 0x45, 0x11, 0xfa, 0xc2, 0x24, 0x09,
0x88, 0x3e, 0x86, 0x1b, 0xa7, 0x43, 0x57, 0xcd, 0x70, 0xdc, 0x32, 0x39, 0x6c, 0x4c, 0x77, 0x42,
0x5e, 0xa9, 0x74, 0xdc, 0x44, 0x39, 0x6c, 0xde, 0x8e, 0xf3, 0xe5, 0x59, 0xa5, 0x9a, 0xcb, 0x2a,
0x4f, 0x60, 0xc3, 0xa4, 0xc0, 0x74, 0x11, 0xf4, 0x85, 0x05, 0x2b, 0x8f, 0xfd, 0x81, 0x27, 0xef,
0xa1, 0x62, 0x2b, 0xdc, 0x04, 0x70, 0xc8, 0x65, 0x87, 0x50, 0xda, 0xed, 0x13, 0x61, 0x01, 0x05,
0x53, 0x96, 0x09, 0xaf, 0xd7, 0x18, 0xef, 0x43, 0x5d, 0x91, 0x63, 0x3a, 0x65, 0xfe, 0x1d, 0x87,
0x64, 0x2e, 0x1e, 0xe3, 0x05, 0xdf, 0xa3, 0x44, 0xe4, 0x7b, 0x55, 0x0a, 0xab, 0xdc, 0xee, 0x79,
0xef, 0x57, 0x2c, 0x53, 0xd1, 0x2c, 0xa3, 0xa4, 0x8a, 0xf9, 0x7c, 0xaa, 0x88, 0xd7, 0x8f, 0xbb,
0x9e, 0x3b, 0x24, 0x6e, 0x1c, 0xf4, 0xfc, 0x3c, 0x15, 0x0c, 0xc2, 0xb0, 0xc2, 0x21, 0x87, 0xd0,
0xf1, 0x30, 0x6a, 0x2d, 0xb0, 0x7c, 0x91, 0xc1, 0xe1, 0x67, 0xb0, 0x5d, 0xac, 0xda, 0x74, 0xe6,
0x3a, 0x87, 0x95, 0x67, 0xe3, 0x41, 0x34, 0xc1, 0xd1, 0xcf, 0x76, 0x0d, 0xee, 0x43, 0x5d, 0xe1,
0x33, 0x9d, 0xac, 0x5f, 0x59, 0xd0, 0x4c, 0xb2, 0x6d, 0x5a, 0xf2, 0x94, 0x4b, 0x3d, 0x53, 0x2a,
0x8b, 0x13, 0xe4, 0xc3, 0xc1, 0x30, 0x22, 0x21, 0x3b, 0xd0, 0xaa, 0x23, 0xa0, 0x98, 0xdf, 0x09,
0xf9, 0x69, 0x74, 0x46, 0x2e, 0xd9, 0x49, 0x56, 0x9d, 0x04, 0xc4, 0x7f, 0xb5, 0x60, 0xc3, 0x24,
0xe3, 0x54, 0x97, 0xc1, 0x43, 0x80, 0x51, 0x5a, 0x0b, 0xf2, 0x6b, 0xe0, 0xe3, 0xa2, 0x74, 0xc7,
0xb9, 0x3d, 0x1c, 0x0f, 0x87, 0xec, 0x36, 0x55, 0x76, 0xc6, 0x9c, 0x3d, 0x21, 0x2e, 0xd7, 0x23,
0x01, 0xf1, 0x6f, 0x34, 0x71, 0x65, 0x61, 0x54, 0x9a, 0x04, 0x14, 0xb1, 0xe6, 0x58, 0xc5, 0xa4,
0xb2, 0x9b, 0x2d, 0x09, 0xfc, 0xce, 0x82, 0x4d, 0xa3, 0x48, 0xef, 0xd2, 0x84, 0xf8, 0x6f, 0x16,
0xa0, 0x27, 0x83, 0xde, 0x85, 0x42, 0x57, 0x6e, 0xa4, 0xaf, 0xc3, 0x6a, 0x4c, 0x4f, 0x5c, 0xae,
0xb8, 0x62, 0x2a, 0x0d, 0x1f, 0x0b, 0xef, 0x90, 0x2e, 0xf5, 0x3d, 0x61, 0x2e, 0x01, 0xe5, 0x8d,
0x55, 0x2d, 0x0f, 0xb9, 0x85, 0x5c, 0xc8, 0x7d, 0x0a, 0xb5, 0xb6, 0x7b, 0x97, 0xa7, 0x8e, 0xc2,
0xab, 0x9e, 0xb1, 0x66, 0x09, 0x87, 0x37, 0x28, 0x02, 0xc2, 0x9f, 0xc3, 0xba, 0xa6, 0xee, 0x54,
0x07, 0x70, 0x0f, 0xea, 0x52, 0x0a, 0xe5, 0x0c, 0x56, 0x45, 0xa8, 0xcb, 0x35, 0x27, 0x4b, 0x86,
0xc7, 0x2c, 0xd6, 0xe3, 0xeb, 0x80, 0xb8, 0x4c, 0x8a, 0x24, 0xd6, 0xb3, 0x89, 0xd6, 0xd2, 0x12,
0xed, 0x0e, 0x2c, 0xfb, 0x7a, 0x9e, 0xf2, 0x27, 0xcc, 0x53, 0x5f, 0xf0, 0x80, 0xd0, 0xf8, 0xce,
0xd4, 0xab, 0x4c, 0x5c, 0xaf, 0xa7, 0xe4, 0xf8, 0xef, 0x16, 0xbc, 0xd7, 0xf6, 0xae, 0x06, 0x11,
0x89, 0x25, 0x7b, 0xee, 0xcb, 0x0c, 0x7d, 0x7d, 0x1e, 0x2e, 0xbe, 0xa4, 0x52, 0x47, 0x9b, 0xcf,
0x38, 0xda, 0x37, 0x61, 0x8d, 0xf3, 0x52, 0xbd, 0xb5, 0xca, 0xbc, 0x55, 0x5f, 0x28, 0x75, 0xba,
0x5f, 0x58, 0xd0, 0x34, 0x88, 0xfd, 0x7f, 0x75, 0x1d, 0x0f, 0xde, 0x93, 0x45, 0xf9, 0x70, 0x38,
0x49, 0xb0, 0xce, 0x56, 0xf0, 0xfe, 0x56, 0xb9, 0x97, 0x14, 0x86, 0xef, 0x34, 0x5f, 0xfd, 0xde,
0x82, 0xa5, 0x83, 0xce, 0x19, 0x23, 0x9b, 0xa9, 0xc7, 0xbb, 0x03, 0x0d, 0xce, 0xab, 0x4b, 0x23,
0x12, 0x9e, 0x74, 0x47, 0x49, 0xd9, 0x97, 0x47, 0xa3, 0xdb, 0xa2, 0x43, 0xe5, 0xa8, 0xb6, 0x2b,
0x4c, 0x95, 0x45, 0xc6, 0xe9, 0x7d, 0x39, 0x31, 0x56, 0x7c, 0x28, 0xdb, 0x42, 0x36, 0xf6, 0x65,
0x7e, 0x2c, 0x29, 0x02, 0x1d, 0x02, 0xfc, 0xa0, 0xdb, 0x1f, 0x78, 0xcc, 0xd4, 0x62, 0x9e, 0x71,
0xdb, 0x20, 0xba, 0xa8, 0xee, 0x53, 0x5a, 0x47, 0xd9, 0x37, 0xc1, 0x11, 0x7e, 0x65, 0xc1, 0x4a,
0x2a, 0x15, 0x0d, 0xd0, 0xb7, 0xa0, 0x96, 0x98, 0x8f, 0x8a, 0x29, 0x4c, 0x23, 0xa9, 0x4e, 0x04,
0xde, 0x49, 0x29, 0xde, 0x90, 0x9c, 0xd2, 0x16, 0xe3, 0x11, 0x65, 0x52, 0x56, 0x9d, 0x14, 0x81,
0xaf, 0x52, 0x11, 0x69, 0x6c, 0xb9, 0x2c, 0x4f, 0xeb, 0xcd, 0xd8, 0x46, 0x4f, 0x27, 0xf8, 0x4f,
0x16, 0xd4, 0x15, 0xc6, 0xef, 0xca, 0x38, 0x36, 0x2c, 0x25, 0xb6, 0x10, 0xb6, 0x91, 0x30, 0x3e,
0x4d, 0x67, 0x2c, 0x86, 0x70, 0x77, 0xb3, 0xe1, 0xee, 0x4e, 0xa0, 0xf3, 0x05, 0x34, 0x39, 0xc8,
0x67, 0x55, 0x67, 0x51, 0x37, 0x1a, 0xd3, 0xf2, 0x8f, 0x6e, 0xc0, 0x02, 0x27, 0x4b, 0x6e, 0x52,
0x0e, 0x4d, 0xe0, 0x7c, 0x2d, 0xd8, 0x30, 0x31, 0xe3, 0x9d, 0x19, 0x12, 0x4b, 0xac, 0x9d, 0xf6,
0x87, 0xe4, 0x5a, 0x21, 0x58, 0xda, 0x72, 0x93, 0xb4, 0xc2, 0xa1, 0xec, 0x28, 0xb2, 0x92, 0x1b,
0x45, 0x4e, 0x50, 0x94, 0x35, 0x61, 0x5d, 0x93, 0x83, 0x06, 0xf8, 0x29, 0xdc, 0x38, 0x24, 0x43,
0xa2, 0x8c, 0x30, 0x67, 0x31, 0xfa, 0x1a, 0x34, 0x32, 0x5f, 0xa3, 0x01, 0xee, 0x40, 0x23, 0x39,
0xd8, 0xfd, 0x9f, 0xb5, 0xdd, 0x59, 0x39, 0xdc, 0x4f, 0x07, 0x80, 0xfc, 0x73, 0x34, 0x40, 0xdf,
0x48, 0x13, 0xa5, 0x08, 0x22, 0xcd, 0x97, 0x25, 0x01, 0xfe, 0x87, 0xd6, 0x82, 0xd0, 0x83, 0xce,
0x59, 0xb9, 0x58, 0x36, 0x2c, 0xc5, 0x46, 0x53, 0x52, 0xa7, 0x84, 0x73, 0xa1, 0x51, 0x79, 0x33,
0x31, 0x6c, 0x38, 0xbf, 0x7f, 0xe9, 0x75, 0x3e, 0x93, 0x9b, 0x06, 0xe8, 0xfb, 0xb0, 0xc8, 0xef,
0x8d, 0x24, 0x94, 0x27, 0xbd, 0x6e, 0x92, 0x6d, 0xe8, 0xc8, 0x10, 0xdf, 0x5f, 0x33, 0x2a, 0xc1,
0x7b, 0xd5, 0x02, 0x2d, 0x6e, 0x02, 0x70, 0x0e, 0x4a, 0xfa, 0x53, 0x30, 0xf8, 0xd7, 0x16, 0xb4,
0x1c, 0x32, 0xf2, 0xaf, 0xc8, 0x6b, 0x99, 0xbf, 0x05, 0x8b, 0x3c, 0x08, 0xa8, 0xa8, 0xbf, 0x13,
0xf0, 0xb5, 0xe6, 0xdd, 0x6e, 0x6e, 0xde, 0xed, 0xe2, 0x0e, 0x6c, 0x15, 0x48, 0xc3, 0x2f, 0x7e,
0x3a, 0xee, 0xf5, 0x08, 0xa5, 0x62, 0xa2, 0x9c, 0x80, 0x71, 0x84, 0x9e, 0x77, 0x07, 0x43, 0xe2,
0x0a, 0x69, 0x04, 0x84, 0xbf, 0xb4, 0xa0, 0xf9, 0xc0, 0x75, 0xdf, 0x86, 0x6a, 0xae, 0xae, 0x9a,
0x5b, 0xaa, 0xda, 0x63, 0xd8, 0x30, 0x89, 0x32, 0x95, 0x5e, 0x03, 0x68, 0x1c, 0x0e, 0xe8, 0x68,
0x40, 0xa9, 0xcc, 0x11, 0x36, 0x2c, 0xf9, 0xb9, 0x99, 0xac, 0x1f, 0x4c, 0x5c, 0xbd, 0xb7, 0x60,
0xb1, 0x9f, 0xad, 0x6e, 0x05, 0x88, 0x8f, 0x60, 0x35, 0xcb, 0x8a, 0x8f, 0x19, 0x7a, 0x93, 0x8c,
0x19, 0x52, 0x22, 0xfc, 0x17, 0x0b, 0x50, 0x67, 0x1c, 0x91, 0xdc, 0x75, 0xf2, 0x96, 0xa4, 0x8e,
0x0d, 0x37, 0x56, 0x87, 0x46, 0x02, 0x42, 0x18, 0x56, 0x46, 0xe3, 0x88, 0xb8, 0x67, 0xa4, 0xe7,
0x7b, 0x2e, 0x65, 0xdd, 0x5f, 0xdd, 0xc9, 0xe0, 0xf0, 0x31, 0xac, 0x6b, 0x92, 0x4e, 0xa7, 0xf4,
0x2f, 0x2d, 0x68, 0x1d, 0x74, 0xbd, 0x1e, 0x19, 0xbe, 0x7b, 0xd5, 0xf1, 0x09, 0x6c, 0x15, 0xc8,
0x32, 0x9d, 0x72, 0xe7, 0xb0, 0x22, 0xbf, 0xf4, 0x36, 0x1d, 0x70, 0x1f, 0xea, 0x0a, 0x9f, 0xe9,
0x64, 0x1d, 0x02, 0xca, 0xe9, 0xfe, 0x36, 0x25, 0x3e, 0x86, 0x75, 0x8d, 0xdb, 0x74, 0x72, 0xff,
0xd9, 0x82, 0xad, 0xb3, 0xcc, 0x0d, 0x73, 0x32, 0xe8, 0x5d, 0x78, 0xdd, 0x51, 0x52, 0xb1, 0xf4,
0xb3, 0xad, 0x57, 0x3f, 0x6d, 0xbd, 0x3c, 0x41, 0x98, 0xdc, 0x8e, 0x09, 0x9c, 0xd1, 0xba, 0x52,
0xae, 0xf5, 0xbc, 0xae, 0x75, 0xea, 0x5d, 0xd5, 0x8c, 0x77, 0x9d, 0x82, 0x5d, 0x24, 0xe8, 0x54,
0x73, 0xc9, 0xbb, 0xff, 0x5d, 0x03, 0xfe, 0x04, 0x8d, 0xbe, 0x0b, 0xcb, 0xbd, 0xf4, 0x85, 0x13,
0x35, 0x93, 0x7d, 0x99, 0x67, 0x5e, 0x7b, 0xc3, 0x84, 0xa6, 0x01, 0xba, 0x07, 0xb5, 0x9f, 0x24,
0xe3, 0x6f, 0xb4, 0x2e, 0x88, 0xd4, 0xc1, 0xbc, 0xfd, 0x9e, 0x8e, 0xe4, 0xfb, 0x2e, 0x93, 0xd9,
0xaa, 0xdc, 0xa7, 0x4e, 0x75, 0xe5, 0xbe, 0xec, 0x08, 0x76, 0x1f, 0xea, 0x7d, 0xf5, 0x65, 0x12,
0x6d, 0x26, 0xef, 0xcc, 0xb9, 0x47, 0x52, 0xbb, 0x65, 0x5e, 0xa0, 0x01, 0xba, 0x0f, 0x2b, 0x54,
0x79, 0xc4, 0x43, 0x89, 0x6e, 0xb9, 0x67, 0x46, 0x7b, 0xd3, 0x88, 0xa7, 0x01, 0xfa, 0x31, 0x6c,
0xf6, 0xcd, 0x2f, 0x68, 0xe8, 0x56, 0x8e, 0xab, 0xfe, 0x82, 0x65, 0xe3, 0xeb, 0x48, 0x68, 0x80,
0xce, 0x61, 0xab, 0x5f, 0xf4, 0x1c, 0x85, 0x3e, 0x4a, 0x3f, 0x50, 0xf8, 0x4e, 0x66, 0xdf, 0xbe,
0x9e, 0x88, 0x06, 0xe8, 0x19, 0xa0, 0x48, 0x7b, 0x93, 0x41, 0xdb, 0x62, 0xaf, 0xf1, 0xbd, 0xc9,
0xfe, 0xa0, 0x64, 0x95, 0x06, 0xa8, 0x07, 0xad, 0x7e, 0xc1, 0xc0, 0x1f, 0xe1, 0xcc, 0x9f, 0x02,
0x8c, 0x8f, 0x1d, 0xf6, 0x47, 0xd7, 0xd2, 0x70, 0xb9, 0xfb, 0xda, 0xc4, 0x5a, 0xca, 0x6d, 0x1c,
0xb8, 0x4b, 0xb9, 0x0b, 0x46, 0xdd, 0xcf, 0x61, 0xbd, 0xaf, 0x8f, 0x70, 0x91, 0x79, 0x97, 0xf4,
0xb2, 0x9b, 0x65, 0xcb, 0x34, 0x40, 0xc7, 0xd0, 0xb8, 0xc8, 0xce, 0x24, 0x51, 0xf2, 0xcf, 0x08,
0x7d, 0x34, 0x6b, 0xdb, 0x45, 0x4b, 0x52, 0xe5, 0xdc, 0x90, 0x4f, 0x55, 0x59, 0x9f, 0x3b, 0xaa,
0x2a, 0x9b, 0xa6, 0x83, 0x27, 0xb0, 0x36, 0xc8, 0xcf, 0xbd, 0xd0, 0xfb, 0xc9, 0xa8, 0xca, 0x30,
0xc8, 0xb3, 0xb7, 0x8b, 0x17, 0xf9, 0xf7, 0xfa, 0xf9, 0x99, 0x92, 0xfc, 0x9e, 0x69, 0xbc, 0x65,
0x6f, 0x17, 0x2f, 0xf2, 0x40, 0x55, 0x5b, 0x1f, 0x19, 0xa8, 0xb9, 0xf6, 0xca, 0xde, 0x34, 0xe2,
0x69, 0x80, 0x3e, 0x81, 0xa5, 0x04, 0x87, 0x50, 0x8e, 0x28, 0xde, 0xb8, 0xae, 0xe1, 0x78, 0x6a,
0x92, 0x39, 0x03, 0xe5, 0x29, 0xa8, 0x9a, 0x9a, 0xb2, 0x13, 0x86, 0x67, 0xb2, 0xef, 0x55, 0x5a,
0x62, 0x79, 0x40, 0xc6, 0xd6, 0x5c, 0x1e, 0x90, 0xb9, 0x97, 0x8e, 0xbd, 0x27, 0xd7, 0xc2, 0x4a,
0xef, 0xd1, 0x5b, 0x6c, 0xe9, 0x3d, 0x86, 0xae, 0x37, 0xce, 0xf2, 0x4a, 0x9f, 0x2a, 0xb3, 0x7c,
0xb6, 0x13, 0x96, 0x59, 0x3e, 0xd7, 0xd2, 0xc6, 0xaa, 0xe9, 0x9d, 0x58, 0x41, 0xb8, 0x89, 0x16,
0xa0, 0x20, 0xdc, 0x64, 0x55, 0xfe, 0x02, 0x9a, 0xc6, 0x56, 0x04, 0x7d, 0x28, 0xf6, 0x15, 0xb5,
0x4d, 0xf6, 0x4e, 0x39, 0x01, 0x17, 0x57, 0xef, 0x05, 0xa4, 0xb8, 0xc6, 0x8e, 0x45, 0x8a, 0x5b,
0xd0, 0x44, 0xdc, 0x87, 0x15, 0xb5, 0x4e, 0x97, 0xae, 0x98, 0xeb, 0x13, 0xa4, 0x2b, 0x6a, 0x45,
0xfd, 0x31, 0x34, 0x72, 0x95, 0xa1, 0x3c, 0x4a, 0xbd, 0x7a, 0x95, 0x47, 0x69, 0x2a, 0x26, 0x5f,
0x40, 0xd3, 0x58, 0x69, 0x4a, 0xcb, 0x15, 0xd5, 0xc4, 0xd2, 0x72, 0xc5, 0x85, 0xea, 0x3d, 0xa8,
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,
}

16
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);
}

1780
pkg/proto/organization/organization.pb.go Normal file

File diff suppressed because it is too large Load Diff

35
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);
}

642
pkg/proto/sdk_ws/ws.pb.go

File diff suppressed because it is too large Load Diff

25
pkg/proto/sdk_ws/ws.proto

@ -138,18 +138,23 @@ message OrganizationUser {
message DepartmentMember {
string userID = 1;
string DepartmentID = 2;
int32 Order = 3;
string Position = 4;
int32 Leader = 5;
int32 Status = 6;
string Ex = 7;
string departmentID = 2;
int32 order = 3;
string position = 4;
int32 leader = 5;
int32 status = 6;
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{

1
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

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

4
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