diff --git a/.gitignore b/.gitignore index 0947afd71..e4b74c4e9 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ components logs out-test .github +.idea deploy/open_im_demo deploy/open_im_api diff --git a/cmd/open_im_cms_api/Makefile b/cmd/open_im_cms_api/Makefile new file mode 100644 index 000000000..e69de29bb diff --git a/cmd/open_im_cms_api/main.go b/cmd/open_im_cms_api/main.go new file mode 100644 index 000000000..df39c4672 --- /dev/null +++ b/cmd/open_im_cms_api/main.go @@ -0,0 +1,15 @@ +package main + +import ( + "Open_IM/internal/cms_api" + "Open_IM/pkg/utils" + + "github.com/gin-gonic/gin" +) + +func main() { + gin.SetMode(gin.ReleaseMode) + router := cms_api.NewGinRouter() + router.Use(utils.CorsHandler()) + router.Run(":" + "8000") +} diff --git a/cmd/rpc/open_im_admin_cms/main.go b/cmd/rpc/open_im_admin_cms/main.go new file mode 100644 index 000000000..eae1a4505 --- /dev/null +++ b/cmd/rpc/open_im_admin_cms/main.go @@ -0,0 +1,14 @@ +package main + +import ( + rpcMessageCMS "Open_IM/internal/rpc/admin_cms" + "flag" +) + +func main() { + rpcPort := flag.Int("port", 11000, "rpc listening port") + flag.Parse() + rpcServer := rpcMessageCMS.NewAdminCMSServer(*rpcPort) + rpcServer.Run() +} + diff --git a/cmd/rpc/open_im_message_cms/main.go b/cmd/rpc/open_im_message_cms/main.go new file mode 100644 index 000000000..0980d3629 --- /dev/null +++ b/cmd/rpc/open_im_message_cms/main.go @@ -0,0 +1,13 @@ +package main + +import ( + rpcMessageCMS "Open_IM/internal/rpc/message_cms" + "flag" +) + +func main() { + rpcPort := flag.Int("port", 10900, "rpc listening port") + flag.Parse() + rpcServer := rpcMessageCMS.NewMessageCMSServer(*rpcPort) + rpcServer.Run() +} diff --git a/cmd/rpc/open_im_statistics/main.go b/cmd/rpc/open_im_statistics/main.go new file mode 100644 index 000000000..f1f950288 --- /dev/null +++ b/cmd/rpc/open_im_statistics/main.go @@ -0,0 +1,13 @@ +package main + +import ( + "Open_IM/internal/rpc/statistics" + "flag" +) + +func main() { + rpcPort := flag.Int("port", 10800, "rpc listening port") + flag.Parse() + rpcServer := statistics.NewStatisticsServer(*rpcPort) + rpcServer.Run() +} diff --git a/config/config.yaml b/config/config.yaml index ee8ec13c4..7279e8fed 100644 --- a/config/config.yaml +++ b/config/config.yaml @@ -8,10 +8,10 @@ etcd: etcdAddr: [ 127.0.0.1:2379 ] mysql: - dbMysqlAddress: [ 127.0.0.1:13306 ] + dbMysqlAddress: [ 43.128.5.63:13306 ] dbMysqlUserName: root dbMysqlPassword: openIM - dbMysqlDatabaseName: openIM + dbMysqlDatabaseName: openIMtest1 dbTableName: eMsg dbMsgTableNum: 1 dbMaxOpenConns: 20 @@ -19,7 +19,7 @@ mysql: dbMaxLifeTime: 120 mongo: - dbAddress: [ 127.0.0.1:37017 ] + dbAddress: [ 43.128.5.63:37017 ] dbDirect: false dbTimeout: 10 dbDatabase: openIM @@ -30,7 +30,7 @@ mongo: dbRetainChatRecords: 7 redis: - dbAddress: 127.0.0.1:16379 + dbAddress: 43.128.5.63:16379 dbMaxIdle: 128 dbMaxActive: 0 dbIdleTimeout: 120 @@ -70,6 +70,8 @@ endpoints: api: openImApiPort: [ 10000 ] +cmsapi: + openImCMSPort: [ 8000 ] sdk: openImSdkWsPort: [ 30000 ] @@ -90,6 +92,9 @@ rpcport: openImGroupPort: [ 10500 ] openImAuthPort: [ 10600 ] openImPushPort: [ 10700 ] + openImOpenImStatisticPort: [ 10800 ] + OpenImMessageCMSPort: [ 10900 ] + openImAdminCMSPort: [11000] c2c: callbackBeforeSendMsg: switch: false @@ -108,6 +113,9 @@ rpcregistername: openImOnlineMessageRelayName: OnlineMessageRelay openImGroupName: Group openImAuthName: Auth + OpenImStatisticsName: Statistics + OpenImMessageCMSName: MessageCMS + openImAdminCMSName: AdminCMS log: storageLocation: ../logs/ @@ -144,8 +152,8 @@ push: pushUrl: "https://api.jpush.cn/v3/push" pushIntent: "intent:#Intent;component=io.openim.app.enterprisechat/io.openim.app.enterprisechat.MainActivity;end" manager: - appManagerUid: [ "openIM123456","openIM654321" ] - secrets: [ "openIM1","openIM2" ] + appManagerUid: [ "openIM123456","openIM654321", "openIM333", "openIMAdmin"] + secrets: [ "openIM1","openIM2", "openIM333" ] secret: tuoyun diff --git a/go.mod b/go.mod index 50f637f57..6cb3f4412 100644 --- a/go.mod +++ b/go.mod @@ -47,7 +47,7 @@ require ( golang.org/x/image v0.0.0-20210220032944-ac19c3e999fb golang.org/x/net v0.0.0-20210917221730-978cfadd31cf google.golang.org/grpc v1.40.0 - google.golang.org/protobuf v1.27.1 // indirect + google.golang.org/protobuf v1.27.1 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df gopkg.in/mgo.v2 v2.0.0-20190816093944-a6b53ec6cb22 diff --git a/internal/api/group/group.go b/internal/api/group/group.go index c3a228744..6e44efa1c 100644 --- a/internal/api/group/group.go +++ b/internal/api/group/group.go @@ -363,7 +363,6 @@ func GetGroupsInfo(c *gin.Context) { return } log.NewInfo(req.OperationID, "GetGroupsInfo args ", req.String()) - etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) client := rpc.NewGroupClient(etcdConn) RpcResp, err := client.GetGroupsInfo(context.Background(), req) @@ -536,5 +535,4 @@ func TransferGroupOwner(c *gin.Context) { resp := api.TransferGroupOwnerResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}} log.NewInfo(req.OperationID, "TransferGroupOwner api return ", resp) c.JSON(http.StatusOK, resp) - } diff --git a/internal/cms_api/admin/admin.go b/internal/cms_api/admin/admin.go new file mode 100644 index 000000000..02b2390c5 --- /dev/null +++ b/internal/cms_api/admin/admin.go @@ -0,0 +1,42 @@ +package admin + +import ( + "Open_IM/pkg/cms_api_struct" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbAdmin "Open_IM/pkg/proto/admin_cms" + "Open_IM/pkg/utils" + "context" + "strings" + + "github.com/gin-gonic/gin" +) + +// register +func AdminLogin(c *gin.Context) { + var ( + req cms_api_struct.AdminLoginRequest + resp cms_api_struct.AdminLoginResponse + reqPb pbAdmin.AdminLoginReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewInfo("0", utils.GetSelfFuncName(), err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.Secret = req.Secret + reqPb.AdminID = req.AdminName + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImAdminCMSName) + client := pbAdmin.NewAdminCMSClient(etcdConn) + respPb, err := client.AdminLogin(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc failed", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + resp.Token = respPb.Token + openIMHttp.RespHttp200(c, constant.OK, resp) +} diff --git a/internal/cms_api/group/group.go b/internal/cms_api/group/group.go new file mode 100644 index 000000000..c9d926bb5 --- /dev/null +++ b/internal/cms_api/group/group.go @@ -0,0 +1,450 @@ +package group + +import ( + "Open_IM/pkg/cms_api_struct" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + commonPb "Open_IM/pkg/proto/sdk_ws" + "Open_IM/pkg/utils" + "context" + "strings" + + pbGroup "Open_IM/pkg/proto/group" + + "github.com/gin-gonic/gin" +) + +func GetGroupById(c *gin.Context) { + var ( + req cms_api_struct.GetGroupByIdRequest + resp cms_api_struct.GetGroupByIdResponse + reqPb pbGroup.GetGroupByIdReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.GetGroupById(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupById failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + resp.GroupName = respPb.CMSGroup.GroupInfo.GroupName + resp.GroupID = respPb.CMSGroup.GroupInfo.GroupID + resp.CreateTime = (utils.UnixSecondToTime(int64(respPb.CMSGroup.GroupInfo.CreateTime))).String() + resp.ProfilePhoto = respPb.CMSGroup.GroupInfo.FaceURL + resp.GroupMasterName = respPb.CMSGroup.GroupMasterName + resp.GroupMasterId = respPb.CMSGroup.GroupMasterId + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetGroups(c *gin.Context) { + var ( + req cms_api_struct.GetGroupsRequest + resp cms_api_struct.GetGroupsResponse + reqPb pbGroup.GetGroupsReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.Pagination = &commonPb.RequestPagination{} + utils.CopyStructFields(&reqPb.Pagination, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.GetGroups(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetUserInfo failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + for _, v := range respPb.CMSGroups { + resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{ + GroupName: v.GroupInfo.GroupName, + GroupID: v.GroupInfo.GroupID, + GroupMasterName: v.GroupMasterName, + GroupMasterId: v.GroupMasterId, + CreateTime: (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(), + IsBanChat: false, + IsBanPrivateChat: false, + ProfilePhoto: v.GroupInfo.FaceURL, + }) + } + resp.GroupNums = int(respPb.GroupNum) + resp.CurrentPage = int(respPb.Pagination.PageNumber) + resp.ShowNumber = int(respPb.Pagination.ShowNumber) + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetGroupByName(c *gin.Context) { + var ( + req cms_api_struct.GetGroupRequest + resp cms_api_struct.GetGroupResponse + reqPb pbGroup.GetGroupReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupName = req.GroupName + reqPb.Pagination = &commonPb.RequestPagination{} + utils.CopyStructFields(&reqPb.Pagination, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.GetGroup(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroup failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + for _, v := range respPb.CMSGroups { + resp.Groups = append(resp.Groups, cms_api_struct.GroupResponse{ + GroupName: v.GroupInfo.GroupName, + GroupID: v.GroupInfo.GroupID, + GroupMasterName: v.GroupMasterName, + GroupMasterId: v.GroupMasterId, + CreateTime: (utils.UnixSecondToTime(int64(v.GroupInfo.CreateTime))).String(), + IsBanChat: false, + IsBanPrivateChat: false, + ProfilePhoto: v.GroupInfo.FaceURL, + }) + } + resp.CurrentPage = int(respPb.Pagination.PageNumber) + resp.ShowNumber = int(respPb.Pagination.ShowNumber) + resp.GroupNums = int(respPb.GroupNums) + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func CreateGroup(c *gin.Context) { + var ( + req cms_api_struct.CreateGroupRequest + _ cms_api_struct.CreateGroupResponse + reqPb pbGroup.CreateGroupReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupInfo = &commonPb.GroupInfo{} + reqPb.GroupInfo.GroupName = req.GroupName + reqPb.GroupInfo.CreatorUserID = req.GroupMasterId + reqPb.OwnerUserID = req.GroupMasterId + reqPb.OpUserID = req.GroupMasterId + for _, v := range req.GroupMembers { + reqPb.InitMemberList = append(reqPb.InitMemberList, &pbGroup.GroupAddMemberInfo{ + UserID: v, + RoleLevel: 1, + }) + } + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.CreateGroup(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "CreateGroup failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func BanGroupChat(c *gin.Context) { + var ( + req cms_api_struct.BanGroupChatRequest + reqPb pbGroup.OperateGroupStatusReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.Status = constant.GroupBanChat + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateGroupStatus(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BanGroupChat failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) + +} + +func BanPrivateChat(c *gin.Context) { + var ( + req cms_api_struct.BanPrivateChatRequest + reqPb pbGroup.OperateGroupStatusReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.Status = constant.GroupBanPrivateChat + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateGroupStatus(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func OpenGroupChat(c *gin.Context) { + var ( + req cms_api_struct.BanPrivateChatRequest + reqPb pbGroup.OperateGroupStatusReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.Status = constant.GroupOk + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateGroupStatus(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func OpenPrivateChat(c *gin.Context) { + var ( + req cms_api_struct.BanPrivateChatRequest + reqPb pbGroup.OperateGroupStatusReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OpenPrivateChat failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.Status = constant.GroupOk + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateGroupStatus(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func GetGroupMembers(c *gin.Context) { + var ( + req cms_api_struct.GetGroupMembersRequest + reqPb pbGroup.GetGroupMembersCMSReq + resp cms_api_struct.GetGroupMembersResponse + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.Pagination = &commonPb.RequestPagination{ + PageNumber: int32(req.PageNumber), + ShowNumber: int32(req.ShowNumber), + } + reqPb.GroupId = req.GroupId + reqPb.UserName = req.UserName + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.GetGroupMembersCMS(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS failed:", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + resp.ResponsePagination = cms_api_struct.ResponsePagination{ + CurrentPage: int(respPb.Pagination.CurrentPage), + ShowNumber: int(respPb.Pagination.ShowNumber), + } + resp.MemberNums = int(respPb.MemberNums) + for _, groupMembers := range respPb.Members { + resp.GroupMembers = append(resp.GroupMembers, cms_api_struct.GroupMemberResponse{ + MemberPosition: int(groupMembers.RoleLevel), + MemberNickName: groupMembers.Nickname, + MemberId: groupMembers.UserID, + JoinTime: utils.UnixSecondToTime(groupMembers.JoinTime).String(), + }) + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + + +func AddGroupMembers(c *gin.Context) { + var ( + req cms_api_struct.RemoveGroupMembersRequest + resp cms_api_struct.RemoveGroupMembersResponse + reqPb pbGroup.AddGroupMembersCMSReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationId, utils.GetSelfFuncName(),"BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.UserIds = req.Members + reqPb.GroupId = req.GroupId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.AddGroupMembersCMS(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationId, utils.GetSelfFuncName(), "AddGroupMembersCMS failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + resp.Success = respPb.Success + resp.Failed = respPb.Failed + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func RemoveGroupMembers(c *gin.Context) { + var ( + req cms_api_struct.RemoveGroupMembersRequest + resp cms_api_struct.RemoveGroupMembersResponse + reqPb pbGroup.RemoveGroupMembersCMSReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(),"BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.UserIds = req.Members + reqPb.GroupId = req.GroupId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + respPb, err := client.RemoveGroupMembersCMS(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "RemoveGroupMembersCMS failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + resp.Success = respPb.Success + resp.Failed = respPb.Failed + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func DeleteGroup(c *gin.Context) { + var ( + req cms_api_struct.DeleteGroupRequest + _ cms_api_struct.DeleteGroupResponse + reqPb pbGroup.DeleteGroupReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(),"BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.DeleteGroup(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func SetGroupMaster(c *gin.Context) { + var ( + req cms_api_struct.SetGroupMasterRequest + _ cms_api_struct.SetGroupMasterResponse + reqPb pbGroup.OperateUserRoleReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(),"BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.UserId = req.UserId + reqPb.RoleLevel = constant.GroupOwner + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateUserRole(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func SetGroupOrdinaryUsers(c *gin.Context) { + var ( + req cms_api_struct.SetGroupMemberRequest + _ cms_api_struct.AdminLoginResponse + reqPb pbGroup.OperateUserRoleReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.GroupId = req.GroupId + reqPb.UserId = req.UserId + reqPb.RoleLevel = constant.GroupOrdinaryUsers + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.OperateUserRole(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func AlterGroupInfo(c *gin.Context) { + var ( + req cms_api_struct.AlterGroupInfoRequest + _ cms_api_struct.SetGroupMasterResponse + reqPb pbGroup.SetGroupInfoReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.OpUserID = c.MustGet("userID").(string) + reqPb.GroupInfo = &commonPb.GroupInfo{ + GroupID: req.GroupID, + GroupName: req.GroupName, + Introduction: req.Introduction, + Notification: req.Notification, + FaceURL: req.ProfilePhoto, + GroupType: int32(req.GroupType), + } + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) + client := pbGroup.NewGroupClient(etcdConn) + _, err := client.SetGroupInfo(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "DeleteGroup failed", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} \ No newline at end of file diff --git a/internal/cms_api/message_cms/message.go b/internal/cms_api/message_cms/message.go new file mode 100644 index 000000000..5b23a9c17 --- /dev/null +++ b/internal/cms_api/message_cms/message.go @@ -0,0 +1,69 @@ +package messageCMS + +import ( + "Open_IM/pkg/cms_api_struct" + "Open_IM/pkg/common/config" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbMessage "Open_IM/pkg/proto/message_cms" + pbCommon "Open_IM/pkg/proto/sdk_ws" + "Open_IM/pkg/utils" + "context" + "strings" + + "Open_IM/pkg/common/constant" + + "github.com/gin-gonic/gin" +) + +func BroadcastMessage(c *gin.Context) { + var ( + reqPb pbMessage.BoradcastMessageReq + ) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName) + client := pbMessage.NewMessageCMSClient(etcdConn) + _, err := client.BoradcastMessage(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func MassSendMassage(c *gin.Context) { + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func WithdrawMessage(c *gin.Context) { + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func GetChatLogs(c *gin.Context) { + var ( + req cms_api_struct.GetChatLogsRequest + resp cms_api_struct.GetChatLogsResponse + reqPb pbMessage.GetChatLogsReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, resp) + return + } + reqPb.Pagination = &pbCommon.RequestPagination{ + PageNumber: int32(req.PageNumber), + ShowNumber: int32(req.ShowNumber), + } + utils.CopyStructFields(&reqPb, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImMessageCMSName) + client := pbMessage.NewMessageCMSClient(etcdConn) + respPb, err := client.GetChatLogs(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetChatLogs rpc failed", err.Error()) + openIMHttp.RespHttp200(c, err, resp) + return + } + utils.CopyStructFields(&resp, &respPb) + openIMHttp.RespHttp200(c, constant.OK, resp) +} diff --git a/internal/cms_api/middleware/cors.go b/internal/cms_api/middleware/cors.go new file mode 100644 index 000000000..139a001af --- /dev/null +++ b/internal/cms_api/middleware/cors.go @@ -0,0 +1,23 @@ +package middleware + +import ( + "github.com/gin-gonic/gin" + "net/http" +) + +func CorsHandler() gin.HandlerFunc { + return func(context *gin.Context) { + context.Writer.Header().Set("Access-Control-Allow-Origin", "*") + context.Header("Access-Control-Allow-Methods", "*") + context.Header("Access-Control-Allow-Headers", "*") + context.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers,Cache-Control,Content-Language,Content-Type,Expires,Last-Modified,Pragma,FooBar") // 跨域关键设置 让浏览器可以解析 + context.Header("Access-Control-Max-Age", "172800") // 缓存请求信息 单位为秒 + context.Header("Access-Control-Allow-Credentials", "false") // 跨域请求是否需要带cookie信息 默认设置为true + context.Header("content-type", "application/json") // 设置返回格式是json + //Release all option pre-requests + if context.Request.Method == http.MethodOptions { + context.JSON(http.StatusOK, "Options Request!") + } + context.Next() + } +} diff --git a/internal/cms_api/middleware/jwt_auth.go b/internal/cms_api/middleware/jwt_auth.go new file mode 100644 index 000000000..f245fc4ad --- /dev/null +++ b/internal/cms_api/middleware/jwt_auth.go @@ -0,0 +1,24 @@ +package middleware + +import ( + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/common/token_verify" + "Open_IM/pkg/utils" + "github.com/gin-gonic/gin" +) + +func JWTAuth() gin.HandlerFunc { + return func(c *gin.Context) { + ok, userID := token_verify.GetUserIDFromToken(c.Request.Header.Get("token")) + log.NewInfo("0", utils.GetSelfFuncName(), "userID: ", userID) + c.Set("userID", userID) + if !ok { + log.NewError("","GetUserIDFromToken false ", c.Request.Header.Get("token")) + c.Abort() + http.RespHttp200(c, constant.ErrParseToken, nil) + return + } + } +} diff --git a/internal/cms_api/organization/organization.go b/internal/cms_api/organization/organization.go new file mode 100644 index 000000000..f775283ca --- /dev/null +++ b/internal/cms_api/organization/organization.go @@ -0,0 +1,49 @@ +package organization + +import ( + "github.com/gin-gonic/gin" +) + +func GetStaffs(c *gin.Context) { + +} + +func GetOrganizations(c *gin.Context) { + +} + +func GetSquads(c *gin.Context) { + +} + +func AlterStaff(c *gin.Context) { + +} + +func AddOrganization(c *gin.Context) { + +} + +func InquireOrganization(g *gin.Context) { + +} + +func AlterOrganization(c *gin.Context) { + +} + +func DeleteOrganization(g *gin.Context) { + +} + +func GetOrganizationSquads(c *gin.Context) { + +} + +func AlterStaffsInfo(c *gin.Context) { + +} + +func AddChildOrganization(c *gin.Context) { + +} diff --git a/internal/cms_api/router.go b/internal/cms_api/router.go new file mode 100644 index 000000000..941cc5bf5 --- /dev/null +++ b/internal/cms_api/router.go @@ -0,0 +1,95 @@ +package cms_api + +import ( + "Open_IM/internal/cms_api/admin" + "Open_IM/internal/cms_api/group" + messageCMS "Open_IM/internal/cms_api/message_cms" + "Open_IM/internal/cms_api/middleware" + "Open_IM/internal/cms_api/organization" + "Open_IM/internal/cms_api/statistics" + "Open_IM/internal/cms_api/user" + + "github.com/gin-gonic/gin" +) + +func NewGinRouter() *gin.Engine { + gin.SetMode(gin.ReleaseMode) + baseRouter := gin.Default() + router := baseRouter.Group("/api") + router.Use(middleware.CorsHandler()) + adminRouterGroup := router.Group("/admin") + { + adminRouterGroup.POST("/login", admin.AdminLogin) + } + r2 := router.Group("") + r2.Use(middleware.JWTAuth()) + statisticsRouterGroup := r2.Group("/statistics") + { + statisticsRouterGroup.GET("/get_messages_statistics", statistics.GetMessagesStatistics) + statisticsRouterGroup.GET("/get_user_statistics", statistics.GetUserStatistics) + statisticsRouterGroup.GET("/get_group_statistics", statistics.GetGroupStatistics) + statisticsRouterGroup.GET("/get_active_user", statistics.GetActiveUser) + statisticsRouterGroup.GET("/get_active_group", statistics.GetActiveGroup) + } + organizationRouterGroup := r2.Group("/organization") + { + organizationRouterGroup.GET("/get_staffs", organization.GetStaffs) + organizationRouterGroup.GET("/get_organizations", organization.GetOrganizations) + organizationRouterGroup.GET("/get_squad", organization.GetSquads) + organizationRouterGroup.POST("/add_organization", organization.AddOrganization) + organizationRouterGroup.POST("/alter_staff", organization.AlterStaff) + organizationRouterGroup.GET("/inquire_organization", organization.InquireOrganization) + organizationRouterGroup.POST("/alter_organization", organization.AlterOrganization) + organizationRouterGroup.POST("/delete_organization", organization.DeleteOrganization) + organizationRouterGroup.POST("/get_organization_squad", organization.GetOrganizationSquads) + organizationRouterGroup.PATCH("/alter_corps_info", organization.AlterStaffsInfo) + organizationRouterGroup.POST("/add_child_org", organization.AddChildOrganization) + } + groupRouterGroup := r2.Group("/group") + { + groupRouterGroup.GET("/get_group_by_id", group.GetGroupById) + groupRouterGroup.GET("/get_groups", group.GetGroups) + groupRouterGroup.GET("/get_group_by_name", group.GetGroupByName) + groupRouterGroup.GET("/get_group_members", group.GetGroupMembers) + groupRouterGroup.POST("/create_group", group.CreateGroup) + groupRouterGroup.POST("/add_members", group.AddGroupMembers) + groupRouterGroup.POST("/remove_members", group.RemoveGroupMembers) + groupRouterGroup.POST("/ban_group_private_chat", group.BanPrivateChat) + groupRouterGroup.POST("/open_group_private_chat", group.OpenPrivateChat) + groupRouterGroup.POST("/ban_group_chat", group.BanGroupChat) + groupRouterGroup.POST("/open_group_chat", group.OpenGroupChat) + groupRouterGroup.POST("/delete_group", group.DeleteGroup) + groupRouterGroup.POST("/get_members_in_group", group.GetGroupMembers) + groupRouterGroup.POST("/set_group_master", group.SetGroupMaster) + groupRouterGroup.POST("/set_group_ordinary_user", group.SetGroupOrdinaryUsers) + groupRouterGroup.POST("/alter_group_info", group.AlterGroupInfo) + } + userRouterGroup := r2.Group("/user") + { + userRouterGroup.POST("/resign", user.ResignUser) + userRouterGroup.GET("/get_user", user.GetUserById) + userRouterGroup.POST("/alter_user", user.AlterUser) + userRouterGroup.GET("/get_users", user.GetUsers) + userRouterGroup.POST("/add_user", user.AddUser) + userRouterGroup.POST("/unblock_user", user.UnblockUser) + userRouterGroup.POST("/block_user", user.BlockUser) + userRouterGroup.GET("/get_block_users", user.GetBlockUsers) + userRouterGroup.GET("/get_block_user", user.GetBlockUserById) + userRouterGroup.POST("/delete_user", user.DeleteUser) + userRouterGroup.GET("/get_users_by_name", user.GetUsersByName) + } + friendRouterGroup := r2.Group("/friend") + { + friendRouterGroup.POST("/get_friends_by_id") + friendRouterGroup.POST("/set_friend") + friendRouterGroup.POST("/remove_friend") + } + messageCMSRouterGroup := r2.Group("/message") + { + messageCMSRouterGroup.GET("/get_chat_logs", messageCMS.GetChatLogs) + messageCMSRouterGroup.POST("/broadcast_message", messageCMS.BroadcastMessage) + messageCMSRouterGroup.POST("/mass_send_message", messageCMS.MassSendMassage) + messageCMSRouterGroup.POST("/withdraw_message", messageCMS.WithdrawMessage) + } + return baseRouter +} diff --git a/internal/cms_api/statistics/statistics.go b/internal/cms_api/statistics/statistics.go new file mode 100644 index 000000000..fd6485591 --- /dev/null +++ b/internal/cms_api/statistics/statistics.go @@ -0,0 +1,222 @@ +package statistics + +import ( + "Open_IM/pkg/cms_api_struct" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pb "Open_IM/pkg/proto/statistics" + "Open_IM/pkg/utils" + "context" + "strings" + + "github.com/gin-gonic/gin" +) + +func GetMessagesStatistics(c *gin.Context) { + var ( + req cms_api_struct.GetMessageStatisticsRequest + resp cms_api_struct.GetMessageStatisticsResponse + reqPb pb.GetMessageStatisticsReq + ) + reqPb.StatisticsReq = &pb.StatisticsReq{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.StatisticsReq, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetMessageStatistics(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, constant.ErrServer, resp) + log.NewError("0", utils.GetSelfFuncName(), err.Error()) + return + } + // utils.CopyStructFields(&resp, respPb) + resp.GroupMessageNum = int(respPb.GroupMessageNum) + resp.PrivateMessageNum = int(respPb.PrivateMessageNum) + for _, v := range respPb.PrivateMessageNumList { + resp.PrivateMessageNumList = append(resp.PrivateMessageNumList, struct { + Date string "json:\"date\"" + MessageNum int "json:\"message_num\"" + }{ + Date: v.Date, + MessageNum: int(v.Num), + }) + } + for _, v := range respPb.GroupMessageNumList { + resp.GroupMessageNumList = append(resp.GroupMessageNumList, struct { + Date string "json:\"date\"" + MessageNum int "json:\"message_num\"" + }{ + Date: v.Date, + MessageNum: int(v.Num), + }) + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetUserStatistics(c *gin.Context) { + var ( + req cms_api_struct.GetUserStatisticsRequest + resp cms_api_struct.GetUserStatisticsResponse + reqPb pb.GetUserStatisticsReq + ) + reqPb.StatisticsReq = &pb.StatisticsReq{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", utils.GetSelfFuncName(), "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.StatisticsReq, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetUserStatistics(context.Background(), &reqPb) + if err != nil { + log.NewError("0", utils.GetSelfFuncName(), err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + // utils.CopyStructFields(&resp, respPb) + resp.ActiveUserNum = int(respPb.ActiveUserNum) + resp.IncreaseUserNum = int(respPb.IncreaseUserNum) + resp.TotalUserNum = int(respPb.TotalUserNum) + for _, v := range respPb.ActiveUserNumList { + resp.ActiveUserNumList = append(resp.ActiveUserNumList, struct { + Date string "json:\"date\"" + ActiveUserNum int "json:\"active_user_num\"" + }{ + Date: v.Date, + ActiveUserNum: int(v.Num), + }) + } + for _, v := range respPb.IncreaseUserNumList { + resp.IncreaseUserNumList = append(resp.IncreaseUserNumList, struct { + Date string "json:\"date\"" + IncreaseUserNum int "json:\"increase_user_num\"" + }{ + Date: v.Date, + IncreaseUserNum: int(v.Num), + }) + } + for _, v := range respPb.TotalUserNumList { + resp.TotalUserNumList = append(resp.TotalUserNumList, struct { + Date string "json:\"date\"" + TotalUserNum int "json:\"total_user_num\"" + }{ + Date: v.Date, + TotalUserNum: int(v.Num), + }) + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetGroupStatistics(c *gin.Context) { + var ( + req cms_api_struct.GetGroupStatisticsRequest + resp cms_api_struct.GetGroupStatisticsResponse + reqPb pb.GetGroupStatisticsReq + ) + reqPb.StatisticsReq = &pb.StatisticsReq{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.StatisticsReq, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetGroupStatistics(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + // utils.CopyStructFields(&resp, respPb) + resp.IncreaseGroupNum = int(respPb.GetIncreaseGroupNum()) + resp.TotalGroupNum = int(respPb.GetTotalGroupNum()) + for _, v := range respPb.IncreaseGroupNumList { + resp.IncreaseGroupNumList = append(resp.IncreaseGroupNumList, + struct { + Date string "json:\"date\"" + IncreaseGroupNum int "json:\"increase_group_num\"" + }{ + Date: v.Date, + IncreaseGroupNum: int(v.Num), + }) + } + for _, v := range respPb.TotalGroupNumList { + resp.TotalGroupNumList = append(resp.TotalGroupNumList, + struct { + Date string "json:\"date\"" + TotalGroupNum int "json:\"total_group_num\"" + }{ + Date: v.Date, + TotalGroupNum: int(v.Num), + }) + + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetActiveUser(c *gin.Context) { + var ( + req cms_api_struct.GetActiveUserRequest + resp cms_api_struct.GetActiveUserResponse + reqPb pb.GetActiveUserReq + ) + reqPb.StatisticsReq = &pb.StatisticsReq{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.StatisticsReq, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetActiveUser(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + utils.CopyStructFields(&resp.ActiveUserList, respPb.Users) + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetActiveGroup(c *gin.Context) { + var ( + req cms_api_struct.GetActiveGroupRequest + resp cms_api_struct.GetActiveGroupResponse + reqPb pb.GetActiveGroupReq + ) + reqPb.StatisticsReq = &pb.StatisticsReq{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.StatisticsReq, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImStatisticsName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetActiveGroup(context.Background(), &reqPb) + if err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrServer, nil) + return + } + for _, group := range respPb.Groups { + resp.ActiveGroupList = append(resp.ActiveGroupList, struct { + GroupName string "json:\"group_name\"" + GroupId string "json:\"group_id\"" + MessageNum int "json:\"message_num\"" + }{ + GroupName: group.GroupName, + GroupId: group.GroupId, + MessageNum: int(group.MessageNum), + }) + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} diff --git a/internal/cms_api/user/user.go b/internal/cms_api/user/user.go new file mode 100644 index 000000000..c87aa4d7f --- /dev/null +++ b/internal/cms_api/user/user.go @@ -0,0 +1,308 @@ +package user + +import ( + "Open_IM/pkg/cms_api_struct" + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + commonPb "Open_IM/pkg/proto/sdk_ws" + pb "Open_IM/pkg/proto/user" + "Open_IM/pkg/utils" + "context" + "fmt" + "net/http" + "strings" + + "github.com/gin-gonic/gin" +) + +func GetUserById(c *gin.Context) { + var ( + req cms_api_struct.GetUserRequest + resp cms_api_struct.GetUserResponse + reqPb pb.GetUserByIdReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetUserById(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + if respPb.User.UserId == "" { + openIMHttp.RespHttp200(c, constant.OK, nil) + return + } + utils.CopyStructFields(&resp, respPb.User) + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetUsersByName(c *gin.Context) { + var ( + req cms_api_struct.GetUsersByNameRequest + resp cms_api_struct.GetUsersByNameResponse + reqPb pb.GetUsersByNameReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.UserName = req.UserName + reqPb.Pagination = &commonPb.RequestPagination{ + PageNumber: int32(req.PageNumber), + ShowNumber: int32(req.ShowNumber), + } + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetUsersByName(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "rpc", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + utils.CopyStructFields(&resp.Users, respPb.Users) + resp.ShowNumber = int(respPb.Pagination.ShowNumber) + resp.CurrentPage = int(respPb.Pagination.CurrentPage) + resp.UserNums = respPb.UserNums + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetUsers(c *gin.Context) { + var ( + req cms_api_struct.GetUsersRequest + resp cms_api_struct.GetUsersResponse + reqPb pb.GetUsersReq + ) + reqPb.Pagination = &commonPb.RequestPagination{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb.Pagination, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetUsers(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, err, resp) + return + } + utils.CopyStructFields(&resp.Users, respPb.User) + resp.ShowNumber = int(respPb.Pagination.ShowNumber) + resp.CurrentPage = int(respPb.Pagination.CurrentPage) + resp.UserNums = respPb.UserNums + openIMHttp.RespHttp200(c, constant.OK, resp) + +} + +func ResignUser(c *gin.Context) { + var ( + req cms_api_struct.ResignUserRequest + resp cms_api_struct.ResignUserResponse + reqPb pb.ResignUserReq + ) + if err := c.ShouldBind(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + c.JSON(http.StatusBadRequest, gin.H{"errCode": http.StatusBadRequest, "errMsg": err.Error()}) + return + } + utils.CopyStructFields(&reqPb, &req) + fmt.Println(reqPb.UserId) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + _, err := client.ResignUser(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, err, resp) + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func AlterUser(c *gin.Context) { + var ( + req cms_api_struct.AlterUserRequest + resp cms_api_struct.AlterUserResponse + reqPb pb.AlterUserReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, resp) + return + } + utils.CopyStructFields(&reqPb, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + _, err := client.AlterUser(context.Background(), &reqPb) + if err != nil { + log.NewError("0", "microserver failed ", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func AddUser(c *gin.Context) { + var ( + req cms_api_struct.AddUserRequest + reqPb pb.AddUserReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + utils.CopyStructFields(&reqPb, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + _, err := client.AddUser(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, err, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} + +func BlockUser(c *gin.Context) { + var ( + req cms_api_struct.BlockUserRequest + resp cms_api_struct.BlockUserResponse + reqPb pb.BlockUserReq + ) + if err := c.BindJSON(&req); err != nil { + fmt.Println(err) + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, resp) + return + } + utils.CopyStructFields(&reqPb, &req) + fmt.Println(reqPb, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + fmt.Println(reqPb) + _, err := client.BlockUser(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, err, resp) + return + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func UnblockUser(c *gin.Context) { + var ( + req cms_api_struct.UnblockUserRequest + resp cms_api_struct.UnBlockUserResponse + reqPb pb.UnBlockUserReq + ) + if err := c.ShouldBind(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, resp) + return + } + utils.CopyStructFields(&reqPb, &req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + _, err := client.UnBlockUser(context.Background(), &reqPb) + if err != nil { + openIMHttp.RespHttp200(c, err, resp) + return + } + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetBlockUsers(c *gin.Context) { + var ( + req cms_api_struct.GetBlockUsersRequest + resp cms_api_struct.GetBlockUsersResponse + reqPb pb.GetBlockUsersReq + respPb *pb.GetBlockUsersResp + ) + reqPb.Pagination = &commonPb.RequestPagination{} + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "ShouldBindQuery failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, resp) + return + } + utils.CopyStructFields(&reqPb.Pagination, &req) + log.NewInfo(reqPb.OperationID, utils.GetSelfFuncName(), "blockUsers", reqPb.Pagination, req) + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetBlockUsers(context.Background(), &reqPb) + if err != nil { + log.NewError(reqPb.OperationID, utils.GetSelfFuncName(), "GetBlockUsers rpc", err.Error()) + openIMHttp.RespHttp200(c, err, resp) + return + } + for _, v := range respPb.BlockUsers { + resp.BlockUsers = append(resp.BlockUsers, cms_api_struct.BlockUser{ + UserResponse: cms_api_struct.UserResponse{ + UserId: v.User.UserId, + ProfilePhoto: v.User.ProfilePhoto, + Nickname: v.User.Nickname, + IsBlock: v.User.IsBlock, + CreateTime: v.User.CreateTime, + }, + BeginDisableTime: v.BeginDisableTime, + EndDisableTime: v.EndDisableTime, + }) + } + resp.ShowNumber = int(respPb.Pagination.ShowNumber) + resp.CurrentPage = int(respPb.Pagination.CurrentPage) + resp.UserNums = respPb.UserNums + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func GetBlockUserById(c *gin.Context) { + var ( + req cms_api_struct.GetBlockUserRequest + resp cms_api_struct.GetBlockUserResponse + reqPb pb.GetBlockUserByIdReq + ) + if err := c.ShouldBindQuery(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.UserId = req.UserId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + respPb, err := client.GetBlockUserById(context.Background(), &reqPb) + if err != nil { + log.NewError("0", "GetBlockUserById rpc failed ", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + resp.EndDisableTime = respPb.BlockUser.EndDisableTime + resp.BeginDisableTime = respPb.BlockUser.BeginDisableTime + utils.CopyStructFields(&resp, respPb.BlockUser.User) + openIMHttp.RespHttp200(c, constant.OK, resp) +} + +func DeleteUser(c *gin.Context) { + var ( + req cms_api_struct.DeleteUserRequest + reqPb pb.DeleteUserReq + ) + if err := c.BindJSON(&req); err != nil { + log.NewError("0", "BindJSON failed ", err.Error()) + openIMHttp.RespHttp200(c, constant.ErrArgs, nil) + return + } + reqPb.UserId = req.UserId + etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImUserName) + client := pb.NewUserClient(etcdConn) + _, err := client.DeleteUser(context.Background(), &reqPb) + if err != nil { + log.NewError("0", "DeleteUser rpc failed ", err.Error()) + openIMHttp.RespHttp200(c, err, nil) + return + } + openIMHttp.RespHttp200(c, constant.OK, nil) +} diff --git a/internal/push/logic/push_to_client.go b/internal/push/logic/push_to_client.go index 315430c8b..721405a78 100644 --- a/internal/push/logic/push_to_client.go +++ b/internal/push/logic/push_to_client.go @@ -121,12 +121,12 @@ func MsgToUser(pushMsg *pbPush.PushMsgReq) { // case constant.GroupChatType: // etcdConn := getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName) // client := pbGroup.NewGroupClient(etcdConn) -// req := &pbGroup.GetGroupAllMemberReq{ +// req := &pbGroup.Req{ // GroupID: m.RecvID, // Token: config.Config.Secret, // OperationID: m.OperationID, // } -// reply, err := client.GetGroupAllMember(context.Background(), req) +// reply, err := client.(context.Background(), req) // if err != nil { // log.Error(m.Token, m.OperationID, "rpc getGroupInfo failed, err = %s", err.Error()) // return diff --git a/internal/rpc/admin_cms/admin_cms.go b/internal/rpc/admin_cms/admin_cms.go new file mode 100644 index 000000000..8703485a7 --- /dev/null +++ b/internal/rpc/admin_cms/admin_cms.go @@ -0,0 +1,91 @@ +package admin_cms + +import ( + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + openIMHttp "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" + "Open_IM/pkg/common/token_verify" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbAdminCMS "Open_IM/pkg/proto/admin_cms" + "Open_IM/pkg/utils" + "context" + "google.golang.org/grpc" + "net" + "strconv" + "strings" +) + +type adminCMSServer struct { + rpcPort int + rpcRegisterName string + etcdSchema string + etcdAddr []string +} + +func NewAdminCMSServer(port int) *adminCMSServer { + log.NewPrivateLog("AdminCMS") + return &adminCMSServer{ + rpcPort: port, + rpcRegisterName: config.Config.RpcRegisterName.OpenImAdminCMSName, + etcdSchema: config.Config.Etcd.EtcdSchema, + etcdAddr: config.Config.Etcd.EtcdAddr, + } +} + +func (s *adminCMSServer) Run() { + log.NewInfo("0", "AdminCMS rpc start ") + ip := utils.ServerIP + registerAddress := ip + ":" + strconv.Itoa(s.rpcPort) + //listener network + listener, err := net.Listen("tcp", registerAddress) + if err != nil { + log.NewError("0", "Listen failed ", err.Error(), registerAddress) + return + } + log.NewInfo("0", "listen network success, ", registerAddress, listener) + defer listener.Close() + //grpc server + srv := grpc.NewServer() + defer srv.GracefulStop() + //Service registers with etcd + pbAdminCMS.RegisterAdminCMSServer(srv, s) + err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10) + if err != nil { + log.NewError("0", "RegisterEtcd failed ", err.Error()) + return + } + err = srv.Serve(listener) + if err != nil { + log.NewError("0", "Serve failed ", err.Error()) + return + } + log.NewInfo("0", "message cms rpc success") +} + +func (s *adminCMSServer) AdminLogin(_ context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) + resp := &pbAdminCMS.AdminLoginResp{} + for _, adminID := range config.Config.Manager.AppManagerUid{ + if adminID == req.AdminID { + for _, secret := range config.Config.Manager.Secrets { + if secret == req.Secret { + token, expTime, err := token_verify.CreateToken(adminID,9843) + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error()) + return resp, openIMHttp.WrapError(constant.ErrTokenUnknown) + } + resp.Token = token + break + } + } + } + } + + if resp.Token == "" { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed") + return resp, openIMHttp.WrapError(constant.ErrTokenMalformed) + } + return resp, nil +} \ No newline at end of file diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 3d40b41be..2a0f59f8d 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -6,6 +6,7 @@ import ( "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/http" "Open_IM/pkg/common/log" "Open_IM/pkg/common/token_verify" cp "Open_IM/pkg/common/utils" @@ -14,11 +15,12 @@ import ( open_im_sdk "Open_IM/pkg/proto/sdk_ws" "Open_IM/pkg/utils" "context" - "google.golang.org/grpc" "net" "strconv" "strings" "time" + + "google.golang.org/grpc" ) type groupServer struct { @@ -582,7 +584,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf group, err := imdb.GetGroupInfoByGroupID(req.GroupInfo.GroupID) if err != nil { log.NewError(req.OperationID, "GetGroupInfoByGroupID failed ", err.Error(), req.GroupInfo.GroupID) - return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, nil + return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrAccess.ErrMsg}}, http.WrapError(constant.ErrDB) } ////bitwise operators: 0001:groupName; 0010:Notification 0100:Introduction; 1000:FaceUrl; 10000:owner @@ -605,7 +607,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf err = imdb.SetGroupInfo(groupInfo) if err != nil { log.NewError(req.OperationID, "SetGroupInfo failed ", err.Error(), groupInfo) - return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, nil + return &pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{ErrCode: constant.ErrDB.ErrCode, ErrMsg: constant.ErrDB.ErrMsg}}, http.WrapError(constant.ErrDB) } log.NewInfo(req.OperationID, "SetGroupInfo rpc return ", pbGroup.SetGroupInfoResp{CommonResp: &pbGroup.CommonResp{}}) if changedType != 0 { @@ -639,6 +641,237 @@ func (s *groupServer) TransferGroupOwner(_ context.Context, req *pbGroup.Transfe } +func (s *groupServer) GetGroupById(_ context.Context, req *pbGroup.GetGroupByIdReq) (*pbGroup.GetGroupByIdResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) + resp := &pbGroup.GetGroupByIdResp{CMSGroup: &pbGroup.CMSGroup{ + GroupInfo: &open_im_sdk.GroupInfo{}, + }} + group, err := imdb.GetGroupById(req.GroupId) + if err != nil { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroupById error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + resp.CMSGroup.GroupInfo = &open_im_sdk.GroupInfo{ + GroupID: group.GroupID, + GroupName: group.GroupName, + FaceURL: group.FaceURL, + OwnerUserID: group.CreatorUserID, + MemberCount: 0, + Status: group.Status, + CreatorUserID: group.CreatorUserID, + GroupType: group.GroupType, + } + groupMember, err := imdb.GetGroupMaster(group.GroupID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + resp.CMSGroup.GroupMasterName = groupMember.Nickname + resp.CMSGroup.GroupMasterId = groupMember.UserID + resp.CMSGroup.GroupInfo.CreatorUserID = group.CreatorUserID + return resp, nil +} + +func (s *groupServer) GetGroup(_ context.Context, req *pbGroup.GetGroupReq) (*pbGroup.GetGroupResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) + resp := &pbGroup.GetGroupResp{ + CMSGroups: []*pbGroup.CMSGroup{}, + } + groups, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsByName error", req.String()) + return resp, http.WrapError(constant.ErrDB) + } + nums, err := imdb.GetGroupsCountNum(db.Group{GroupName:req.GroupName}) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + resp.GroupNums = nums + resp.Pagination = &open_im_sdk.RequestPagination{ + PageNumber: req.Pagination.PageNumber, + ShowNumber: req.Pagination.ShowNumber, + } + for _, v := range groups { + groupMember, err := imdb.GetGroupMaster(v.GroupID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMaster error", err.Error()) + continue + } + resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{ + GroupInfo: &open_im_sdk.GroupInfo{ + GroupID: v.GroupID, + GroupName: v.GroupName, + FaceURL: v.FaceURL, + OwnerUserID: v.CreatorUserID, + Status: v.Status, + CreatorUserID: v.CreatorUserID, + }, + GroupMasterName: groupMember.Nickname, + GroupMasterId: groupMember.UserID, + }) + } + return resp, nil +} + +func (s *groupServer) GetGroups(_ context.Context, req *pbGroup.GetGroupsReq) (*pbGroup.GetGroupsResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetGroups ", req.String()) + resp := &pbGroup.GetGroupsResp{ + CMSGroups: []*pbGroup.CMSGroup{}, + Pagination: &open_im_sdk.RequestPagination{}, + } + groups, err := imdb.GetGroups(int(req.Pagination.PageNumber), int(req.Pagination.ShowNumber)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroups error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + groupsCountNum, err := imdb.GetGroupsCountNum(db.Group{}) + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "groupsCountNum ", groupsCountNum) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupsCountNum", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + resp.GroupNum = int32(groupsCountNum) + resp.Pagination.PageNumber = req.Pagination.PageNumber + resp.Pagination.ShowNumber = req.Pagination.ShowNumber + for _, v := range groups { + groupMember, err := imdb.GetGroupMaster(v.GroupID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + continue + } + resp.CMSGroups = append(resp.CMSGroups, &pbGroup.CMSGroup{ + GroupInfo: &open_im_sdk.GroupInfo{ + GroupID: v.GroupID, + GroupName: v.GroupName, + FaceURL: v.FaceURL, + OwnerUserID: v.CreatorUserID, + Status: v.Status, + CreatorUserID: v.CreatorUserID, + }, + GroupMasterId: groupMember.UserID, + GroupMasterName: groupMember.Nickname, + }) + } + + return resp, nil +} + +func (s *groupServer) OperateGroupStatus(_ context.Context, req *pbGroup.OperateGroupStatusReq) (*pbGroup.OperateGroupStatusResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbGroup.OperateGroupStatusResp{} + if err := imdb.OperateGroupStatus(req.GroupId, req.Status); err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "OperateGroupStatus", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *groupServer) DeleteGroup(_ context.Context, req *pbGroup.DeleteGroupReq) (*pbGroup.DeleteGroupResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbGroup.DeleteGroupResp{} + if err := imdb.DeleteGroup(req.GroupId); err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "DeleteGroup error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *groupServer) OperateUserRole(_ context.Context, req *pbGroup.OperateUserRoleReq) (*pbGroup.OperateUserRoleResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String()) + resp := &pbGroup.OperateUserRoleResp{} + if err := imdb.OperateGroupRole(req.UserId, req.GroupId, req.RoleLevel); err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "OperateGroupRole error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *groupServer) GetGroupMembersCMS(_ context.Context, req *pbGroup.GetGroupMembersCMSReq) (*pbGroup.GetGroupMembersCMSResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String()) + resp := &pbGroup.GetGroupMembersCMSResp{} + groupMembers, err := imdb.GetGroupMembersByGroupIdCMS(req.GroupId, req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(),"GetGroupMembersByGroupIdCMS Error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + groupMembersCount, err := imdb.GetGroupMembersCount(req.GroupId, req.UserName) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupMembersCMS Error", err.Error()) + return resp, http.WrapError(constant.ErrDB) + } + log.NewInfo(req.OperationID, groupMembersCount) + resp.MemberNums = groupMembersCount + for _, groupMember := range groupMembers { + resp.Members = append(resp.Members, &open_im_sdk.GroupMemberFullInfo{ + GroupID: req.GroupId, + UserID: groupMember.UserID, + RoleLevel: groupMember.RoleLevel, + JoinTime: groupMember.JoinTime.Unix(), + Nickname: groupMember.Nickname, + FaceURL: groupMember.FaceURL, + JoinSource: groupMember.JoinSource, + }) + } + resp.Pagination = &open_im_sdk.ResponsePagination{ + CurrentPage: req.Pagination.PageNumber, + ShowNumber: req.Pagination.ShowNumber, + } + return resp, nil +} + +func (s *groupServer) RemoveGroupMembersCMS(_ context.Context, req *pbGroup.RemoveGroupMembersCMSReq) (*pbGroup.RemoveGroupMembersCMSResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "args:", req.String()) + resp := &pbGroup.RemoveGroupMembersCMSResp{} + for _, userId := range req.UserIds { + err := imdb.RemoveGroupMember(req.GroupId, userId) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + resp.Failed = append(resp.Failed, userId) + } else { + resp.Success = append(resp.Success, userId) + } + } + return resp, nil +} + +func (s *groupServer) AddGroupMembersCMS(_ context.Context, req *pbGroup.AddGroupMembersCMSReq) (*pbGroup.AddGroupMembersCMSResp, error) { + log.NewInfo(req.OperationId, utils.GetSelfFuncName(), "args:", req.String()) + resp := &pbGroup.AddGroupMembersCMSResp{} + for _, userId := range req.UserIds { + if isExist := imdb.IsExistGroupMember(req.GroupId, userId); isExist { + log.NewError(req.OperationId, utils.GetSelfFuncName(), "user is exist in group", userId, req.GroupId) + resp.Failed = append(resp.Failed, userId) + continue + } + user, err := imdb.GetUserByUserID(userId) + if err != nil { + log.NewError(req.OperationId, utils.GetSelfFuncName(), "GetUserByUserID", err.Error()) + resp.Failed = append(resp.Failed, userId) + continue + } + groupMember := db.GroupMember{ + GroupID: req.GroupId, + UserID: userId, + Nickname: user.Nickname, + FaceURL: "", + RoleLevel: 1, + JoinTime: time.Time{}, + JoinSource: constant.JoinByAdmin, + OperatorUserID: "CmsAdmin", + Ex: "", + } + if err := imdb.InsertIntoGroupMember(groupMember); err != nil { + log.NewError(req.OperationId, utils.GetSelfFuncName(), "InsertIntoGroupMember failed", req.String()) + resp.Failed = append(resp.Failed, userId) + } else { + resp.Success = append(resp.Success, userId) + } + } + return resp, nil +} + + func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup.GetUserReqApplicationListReq) (*pbGroup.GetUserReqApplicationListResp, error) { log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) resp := &pbGroup.GetUserReqApplicationListResp{} @@ -675,4 +908,4 @@ func (s *groupServer) GetUserReqApplicationList(_ context.Context, req *pbGroup. ErrMsg: "", } return resp, nil -} \ No newline at end of file +} diff --git a/internal/rpc/message_cms/message_cms.go b/internal/rpc/message_cms/message_cms.go new file mode 100644 index 000000000..c0ecf8bbe --- /dev/null +++ b/internal/rpc/message_cms/message_cms.go @@ -0,0 +1,143 @@ +package messageCMS + +import ( + "Open_IM/pkg/common/config" + "Open_IM/pkg/common/constant" + "Open_IM/pkg/common/db" + errors "Open_IM/pkg/common/http" + "context" + + "Open_IM/pkg/common/log" + + imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbMessageCMS "Open_IM/pkg/proto/message_cms" + open_im_sdk "Open_IM/pkg/proto/sdk_ws" + + "Open_IM/pkg/utils" + + "net" + "strconv" + "strings" + + "google.golang.org/grpc" +) + +type messageCMSServer struct { + rpcPort int + rpcRegisterName string + etcdSchema string + etcdAddr []string +} + +func NewMessageCMSServer(port int) *messageCMSServer { + log.NewPrivateLog("MessageCMS") + return &messageCMSServer{ + rpcPort: port, + rpcRegisterName: config.Config.RpcRegisterName.OpenImMessageCMSName, + etcdSchema: config.Config.Etcd.EtcdSchema, + etcdAddr: config.Config.Etcd.EtcdAddr, + } +} + +func (s *messageCMSServer) Run() { + log.NewInfo("0", "messageCMS rpc start ") + ip := utils.ServerIP + registerAddress := ip + ":" + strconv.Itoa(s.rpcPort) + //listener network + listener, err := net.Listen("tcp", registerAddress) + if err != nil { + log.NewError("0", "Listen failed ", err.Error(), registerAddress) + return + } + log.NewInfo("0", "listen network success, ", registerAddress, listener) + defer listener.Close() + //grpc server + srv := grpc.NewServer() + defer srv.GracefulStop() + //Service registers with etcd + pbMessageCMS.RegisterMessageCMSServer(srv, s) + err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10) + if err != nil { + log.NewError("0", "RegisterEtcd failed ", err.Error()) + return + } + err = srv.Serve(listener) + if err != nil { + log.NewError("0", "Serve failed ", err.Error()) + return + } + log.NewInfo("0", "message cms rpc success") +} + +func (s *messageCMSServer) BoradcastMessage(_ context.Context, req *pbMessageCMS.BoradcastMessageReq) (*pbMessageCMS.BoradcastMessageResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "BoradcastMessage", req.String()) + resp := &pbMessageCMS.BoradcastMessageResp{} + return resp, errors.WrapError(constant.ErrDB) +} + +func (s *messageCMSServer) GetChatLogs(_ context.Context, req *pbMessageCMS.GetChatLogsReq) (*pbMessageCMS.GetChatLogsResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String()) + resp := &pbMessageCMS.GetChatLogsResp{} + time, err := utils.TimeStringToTime(req.Date) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "time string parse error", err.Error()) + } + chatLog := db.ChatLog{ + Content: req.Content, + SendTime: time, + } + chatLogs, err := imdb.GetChatLog(chatLog, req.Pagination.PageNumber, req.Pagination.ShowNumber) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetChatLog", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + for _, chatLog := range chatLogs { + pbChatLog := &pbMessageCMS.ChatLogs{ + SessionType: chatLog.SessionType, + ContentType: chatLog.ContentType, + SenderNickName: chatLog.SenderNickname, + SenderId: chatLog.SendID, + SearchContent: req.Content, + WholeContent: chatLog.Content, + Date: chatLog.CreateTime.String(), + } + switch chatLog.SessionType { + case constant.SingleChatType: + recvUser, err := imdb.GetUserByUserID(chatLog.RecvID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByUserID failed", err.Error()) + continue + } + pbChatLog.ReciverId = recvUser.UserID + pbChatLog.ReciverNickName = recvUser.Nickname + case constant.GroupChatType: + group, err := imdb.GetGroupById(chatLog.RecvID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetGroupById failed") + continue + } + pbChatLog.GroupId = group.GroupID + pbChatLog.GroupName = group.GroupName + } + resp.ChatLogs = append(resp.ChatLogs, pbChatLog) + } + resp.Pagination = &open_im_sdk.ResponsePagination{ + CurrentPage: req.Pagination.PageNumber, + ShowNumber: req.Pagination.ShowNumber, + } + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp output: ", resp.String()) + return resp, nil +} + +func (s *messageCMSServer) MassSendMessage(_ context.Context, req *pbMessageCMS.MassSendMessageReq) (*pbMessageCMS.MassSendMessageResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "MassSendMessage", req.String()) + resp := &pbMessageCMS.MassSendMessageResp{} + return resp, nil +} + +func (s *messageCMSServer) WithdrawMessage(_ context.Context, req *pbMessageCMS.WithdrawMessageReq) (*pbMessageCMS.WithdrawMessageResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "WithdrawMessage", req.String()) + resp := &pbMessageCMS.WithdrawMessageResp{} + return resp, nil +} diff --git a/internal/rpc/statistics/statistics.go b/internal/rpc/statistics/statistics.go new file mode 100644 index 000000000..7c805da2f --- /dev/null +++ b/internal/rpc/statistics/statistics.go @@ -0,0 +1,361 @@ +package statistics + +import ( + "Open_IM/pkg/common/config" + "context" + "sync" + "time" + + //"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" + + //cp "Open_IM/pkg/common/utils" + "Open_IM/pkg/grpc-etcdv3/getcdv3" + pbStatistics "Open_IM/pkg/proto/statistics" + + //open_im_sdk "Open_IM/pkg/proto/sdk_ws" + "Open_IM/pkg/utils" + //"context" + "net" + "strconv" + "strings" + + "google.golang.org/grpc" +) + +type statisticsServer struct { + rpcPort int + rpcRegisterName string + etcdSchema string + etcdAddr []string +} + +func NewStatisticsServer(port int) *statisticsServer { + log.NewPrivateLog("Statistics") + return &statisticsServer{ + rpcPort: port, + rpcRegisterName: config.Config.RpcRegisterName.OpenImStatisticsName, + etcdSchema: config.Config.Etcd.EtcdSchema, + etcdAddr: config.Config.Etcd.EtcdAddr, + } +} + +func (s *statisticsServer) Run() { + log.NewInfo("0", "Statistics rpc start ") + ip := utils.ServerIP + registerAddress := ip + ":" + strconv.Itoa(s.rpcPort) + //listener network + listener, err := net.Listen("tcp", registerAddress) + if err != nil { + log.NewError("0", "Listen failed ", err.Error(), registerAddress) + return + } + log.NewInfo("0", "listen network success, ", registerAddress, listener) + defer listener.Close() + //grpc server + srv := grpc.NewServer() + defer srv.GracefulStop() + //Service registers with etcd + pbStatistics.RegisterUserServer(srv, s) + err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), ip, s.rpcPort, s.rpcRegisterName, 10) + if err != nil { + log.NewError("0", "RegisterEtcd failed ", err.Error()) + return + } + err = srv.Serve(listener) + if err != nil { + log.NewError("0", "Serve failed ", err.Error()) + return + } + log.NewInfo("0", "statistics rpc success") +} + +func (s *statisticsServer) GetActiveGroup(_ context.Context, req *pbStatistics.GetActiveGroupReq) (*pbStatistics.GetActiveGroupResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbStatistics.GetActiveGroupResp{} + fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + for _, activeGroup := range activeGroups { + resp.Groups = append(resp.Groups, + &pbStatistics.GroupResp{ + GroupName: activeGroup.Name, + GroupId: activeGroup.Id, + MessageNum: int32(activeGroup.MessageNum), + }) + } + return resp, nil +} + +func (s *statisticsServer) GetActiveUser(_ context.Context, req *pbStatistics.GetActiveUserReq) (*pbStatistics.GetActiveUserResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbStatistics.GetActiveUserResp{} + fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + activeUsers, err := imdb.GetActiveUsers(fromTime, toTime, 12) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + for _, activeUser := range activeUsers { + resp.Users = append(resp.Users, + &pbStatistics.UserResp{ + UserId: activeUser.Id, + NickName: activeUser.Name, + MessageNum: int32(activeUser.MessageNum), + }, + ) + } + return resp, nil +} + +func ParseTimeFromTo(from, to string) (time.Time, time.Time, error) { + var fromTime time.Time + var toTime time.Time + fromTime, err := utils.TimeStringToTime(from) + if err != nil { + return fromTime, toTime, err + } + toTime, err = utils.TimeStringToTime(to) + if err != nil { + return fromTime, toTime, err + } + return fromTime, toTime, nil +} + +func isInOneMonth(from, to time.Time) bool { + return from.Month() == to.Month() && from.Year() == to.Year() +} + +func GetRangeDate(from, to time.Time) [][2]time.Time { + interval := to.Sub(from) + var times [][2]time.Time + switch { + // today + case interval == 0: + times = append(times, [2]time.Time{ + from, from.Add(time.Hour * 24), + }) + // days + case isInOneMonth(from, to): + for i := 0; ; i++ { + fromTime := from.Add(time.Hour * 24 * time.Duration(i)) + toTime := from.Add(time.Hour * 24 * time.Duration(i+1)) + if toTime.After(to.Add(time.Hour * 24)) { + break + } + times = append(times, [2]time.Time{ + fromTime, toTime, + }) + } + // month + case !isInOneMonth(from, to): + for i := 0; ; i++ { + if i == 0 { + fromTime := from + toTime := getFirstDateOfNextNMonth(fromTime, 1) + times = append(times, [2]time.Time{ + fromTime, toTime, + }) + } else { + fromTime := getFirstDateOfNextNMonth(from, i) + toTime := getFirstDateOfNextNMonth(fromTime, 1) + if toTime.After(to) { + toTime = to + times = append(times, [2]time.Time{ + fromTime, toTime, + }) + break + } + times = append(times, [2]time.Time{ + fromTime, toTime, + }) + } + + } + } + return times +} + +func getFirstDateOfNextNMonth(currentTime time.Time, n int) time.Time { + lastOfMonth := time.Date(currentTime.Year(), currentTime.Month(), 1, 0, 0, 0, 0, currentTime.Location()).AddDate(0, n, 0) + return lastOfMonth +} + +func (s *statisticsServer) GetGroupStatistics(_ context.Context, req *pbStatistics.GetGroupStatisticsReq) (*pbStatistics.GetGroupStatisticsResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbStatistics.GetGroupStatisticsResp{} + fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + increaseGroupNum, err := imdb.GetIncreaseGroupNum(fromTime, toTime.Add(time.Hour*24)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + totalGroupNum, err := imdb.GetTotalGroupNum() + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + resp.IncreaseGroupNum = increaseGroupNum + resp.TotalGroupNum = totalGroupNum + times := GetRangeDate(fromTime, toTime) + log.NewInfo(req.OperationID, "times:", times) + wg := &sync.WaitGroup{} + resp.IncreaseGroupNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + resp.TotalGroupNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + log.NewInfo(req.OperationID, resp.TotalGroupNumList, resp.TotalGroupNumList) + wg.Add(len(times)) + for i, v := range times { + go func(wg *sync.WaitGroup, index int, v [2]time.Time) { + defer wg.Done() + num, err := imdb.GetIncreaseGroupNum(v[0], v[1]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error()) + } + resp.IncreaseGroupNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + num, err = imdb.GetGroupNum(v[0]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error()) + } + resp.TotalGroupNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + }(wg, i, v) + } + wg.Wait() + return resp, nil +} + +func (s *statisticsServer) GetMessageStatistics(_ context.Context, req *pbStatistics.GetMessageStatisticsReq) (*pbStatistics.GetMessageStatisticsResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbStatistics.GetMessageStatisticsResp{} + fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + privateMessageNum, err := imdb.GetPrivateMessageNum(fromTime, toTime.Add(time.Hour*24)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + return resp, err + } + groupMessageNum, err := imdb.GetGroupMessageNum(fromTime, toTime.Add(time.Hour*24)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + } + resp.PrivateMessageNum = privateMessageNum + resp.GroupMessageNum = groupMessageNum + times := GetRangeDate(fromTime, toTime) + resp.GroupMessageNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + resp.PrivateMessageNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + wg := &sync.WaitGroup{} + wg.Add(len(times)) + for i, v := range times { + go func(wg *sync.WaitGroup, index int, v [2]time.Time) { + defer wg.Done() + num, err := imdb.GetPrivateMessageNum(v[0], v[1]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error()) + } + resp.PrivateMessageNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + num, err = imdb.GetGroupMessageNum(v[0], v[1]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error()) + } + resp.GroupMessageNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + }(wg, i, v) + } + wg.Wait() + return resp, nil +} + +func (s *statisticsServer) GetUserStatistics(_ context.Context, req *pbStatistics.GetUserStatisticsReq) (*pbStatistics.GetUserStatisticsResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbStatistics.GetUserStatisticsResp{} + fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "ParseTimeFromTo", err.Error()) + return resp, err + } + activeUserNum, err := imdb.GetActiveUserNum(fromTime, toTime.Add(time.Hour*24)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetActiveUserNum", err.Error()) + return resp, err + } + increaseUserNum, err := imdb.GetIncreaseUserNum(fromTime, toTime.Add(time.Hour*24)) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum error", err.Error()) + return resp, err + } + totalUserNum, err := imdb.GetTotalUserNum() + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNum error", err.Error()) + return resp, err + } + resp.ActiveUserNum = activeUserNum + resp.TotalUserNum = totalUserNum + resp.IncreaseUserNum = increaseUserNum + times := GetRangeDate(fromTime, toTime) + resp.TotalUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + resp.ActiveUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + resp.IncreaseUserNumList = make([]*pbStatistics.DateNumList, len(times), len(times)) + wg := &sync.WaitGroup{} + wg.Add(len(times)) + for i, v := range times { + go func(wg *sync.WaitGroup, index int, v [2]time.Time) { + defer wg.Done() + num, err := imdb.GetActiveUserNum(v[0], v[1]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseGroupNum", v, err.Error()) + } + resp.ActiveUserNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + num, err = imdb.GetTotalUserNumByDate(v[0]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetTotalUserNumByDate", v, err.Error()) + } + resp.TotalUserNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + num, err = imdb.GetIncreaseUserNum(v[0], v[1]) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetIncreaseUserNum", v, err.Error()) + } + resp.IncreaseUserNumList[index] = &pbStatistics.DateNumList{ + Date: v[0].String(), + Num: num, + } + }(wg, i, v) + } + wg.Wait() + return resp, nil +} diff --git a/internal/rpc/user/user.go b/internal/rpc/user/user.go index 7494a2e51..7ac1bbec4 100644 --- a/internal/rpc/user/user.go +++ b/internal/rpc/user/user.go @@ -6,6 +6,8 @@ import ( "Open_IM/pkg/common/constant" "Open_IM/pkg/common/db" imdb "Open_IM/pkg/common/db/mysql_model/im_mysql_model" + errors "Open_IM/pkg/common/http" + "Open_IM/pkg/common/log" "Open_IM/pkg/common/token_verify" "Open_IM/pkg/grpc-etcdv3/getcdv3" @@ -14,10 +16,12 @@ import ( pbUser "Open_IM/pkg/proto/user" "Open_IM/pkg/utils" "context" - "google.golang.org/grpc" + "fmt" "net" "strconv" "strings" + + "google.golang.org/grpc" ) type userServer struct { @@ -243,3 +247,211 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbUser.UpdateUserI log.Info(req.OperationID, "UserInfoUpdatedNotification ", req.UserInfo.UserID, req.OpUserID) return &pbUser.UpdateUserInfoResp{CommonResp: &pbUser.CommonResp{}}, nil } + +func (s *userServer) GetUsersByName(ctx context.Context, req *pbUser.GetUsersByNameReq) (*pbUser.GetUsersByNameResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String()) + resp := &pbUser.GetUsersByNameResp{} + users, err := imdb.GetUserByName(req.UserName, req.Pagination.ShowNumber, req.Pagination.PageNumber) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUserByName failed", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + for _, user := range users { + isBlock, err := imdb.UserIsBlock(user.UserID) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error()) + continue + } + resp.Users = append(resp.Users, &pbUser.User{ + ProfilePhoto: user.FaceURL, + Nickname: user.Nickname, + UserId: user.UserID, + CreateTime: user.CreateTime.String(), + IsBlock: isBlock, + }) + } + user := db.User{Nickname: req.UserName} + userNums, err := imdb.GetUsersCount(user) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + resp.UserNums = userNums + resp.Pagination = &sdkws.ResponsePagination{ + CurrentPage: req.Pagination.PageNumber, + ShowNumber: req.Pagination.ShowNumber, + } + return resp, nil +} + +func (s *userServer) GetUserById(ctx context.Context, req *pbUser.GetUserByIdReq) (*pbUser.GetUserByIdResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req:", req.String()) + resp := &pbUser.GetUserByIdResp{User: &pbUser.User{}} + user, err := imdb.GetUserByUserID(req.UserId) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) + return resp, errors.WrapError(constant.ErrDB) + } + isBlock, err := imdb.UserIsBlock(req.UserId) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "req：", req.String()) + return resp, errors.WrapError(constant.ErrDB) + } + resp.User = &pbUser.User{ + ProfilePhoto: user.FaceURL, + Nickname: user.Nickname, + UserId: user.UserID, + CreateTime: user.CreateTime.String(), + IsBlock: isBlock, + } + return resp, nil +} + +func (s *userServer) GetUsers(ctx context.Context, req *pbUser.GetUsersReq) (*pbUser.GetUsersResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String()) + resp := &pbUser.GetUsersResp{User: []*pbUser.User{}} + users, err := imdb.GetUsers(req.Pagination.ShowNumber, req.Pagination.PageNumber) + if err != nil { + return resp, errors.WrapError(constant.ErrDB) + } + for _, v := range users { + isBlock, err := imdb.UserIsBlock(v.UserID) + if err == nil { + user := &pbUser.User{ + ProfilePhoto: v.FaceURL, + UserId: v.UserID, + CreateTime: v.CreateTime.String(), + Nickname: v.Nickname, + IsBlock: isBlock, + } + resp.User = append(resp.User, user) + } + } + user := db.User{} + nums, err := imdb.GetUsersCount(user) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetUsersCount failed", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + resp.UserNums = nums + resp.Pagination = &sdkws.ResponsePagination{ShowNumber: req.Pagination.ShowNumber, CurrentPage: req.Pagination.PageNumber} + return resp, nil +} + +func (s *userServer) ResignUser(ctx context.Context, req *pbUser.ResignUserReq) (*pbUser.ResignUserResp, error) { + log.NewInfo(req.OperationID, "ResignUser args ", req.String()) + return &pbUser.ResignUserResp{}, nil +} + +func (s *userServer) AlterUser(ctx context.Context, req *pbUser.AlterUserReq) (*pbUser.AlterUserResp, error) { + log.NewInfo(req.OperationID, "AlterUser args ", req.String()) + resp := &pbUser.AlterUserResp{} + user := db.User{ + PhoneNumber: strconv.FormatInt(req.PhoneNumber, 10), + Nickname: req.Nickname, + Email: req.Email, + UserID: req.UserId, + } + if err := imdb.UpdateUserInfo(user); err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "UpdateUserInfo", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *userServer) AddUser(ctx context.Context, req *pbUser.AddUserReq) (*pbUser.AddUserResp, error) { + log.NewInfo(req.OperationID, "AddUser args ", req.String()) + resp := &pbUser.AddUserResp{} + err := imdb.AddUser(req.UserId, req.PhoneNumber, req.Name) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "AddUser", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *userServer) BlockUser(ctx context.Context, req *pbUser.BlockUserReq) (*pbUser.BlockUserResp, error) { + log.NewInfo(req.OperationID, "BlockUser args ", req.String()) + fmt.Println("BlockUser args ", req.String()) + resp := &pbUser.BlockUserResp{} + err := imdb.BlockUser(req.UserId, req.EndDisableTime) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "BlockUser", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *userServer) UnBlockUser(ctx context.Context, req *pbUser.UnBlockUserReq) (*pbUser.UnBlockUserResp, error) { + log.NewInfo(req.OperationID, "UnBlockUser args ", req.String()) + resp := &pbUser.UnBlockUserResp{} + err := imdb.UnBlockUser(req.UserId) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "unBlockUser", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + return resp, nil +} + +func (s *userServer) GetBlockUsers(ctx context.Context, req *pbUser.GetBlockUsersReq) (*pbUser.GetBlockUsersResp, error) { + log.NewInfo(req.OperationID, "GetBlockUsers args ", req.String()) + resp := &pbUser.GetBlockUsersResp{} + blockUsers, err := imdb.GetBlockUsers(req.Pagination.ShowNumber, req.Pagination.PageNumber) + if err != nil { + log.Error(req.OperationID, utils.GetSelfFuncName(), "GetBlockUsers", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + for _, v := range blockUsers { + resp.BlockUsers = append(resp.BlockUsers, &pbUser.BlockUser{ + User: &pbUser.User{ + ProfilePhoto: v.User.FaceURL, + Nickname: v.User.Nickname, + UserId: v.User.UserID, + IsBlock: true, + }, + BeginDisableTime: (v.BeginDisableTime).String(), + EndDisableTime: (v.EndDisableTime).String(), + }) + } + resp.Pagination = &sdkws.ResponsePagination{} + resp.Pagination.ShowNumber = req.Pagination.ShowNumber + resp.Pagination.CurrentPage = req.Pagination.PageNumber + nums, err := imdb.GetBlockUsersNumCount() + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetBlockUsersNumCount failed", err.Error()) + return resp, errors.WrapError(constant.ErrDB) + } + resp.UserNums = nums + return resp, nil +} + +func (s *userServer) GetBlockUserById(_ context.Context, req *pbUser.GetBlockUserByIdReq) (*pbUser.GetBlockUserByIdResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetBlockUserById args ", req.String()) + resp := &pbUser.GetBlockUserByIdResp{} + user, err := imdb.GetBlockUserById(req.UserId) + if err != nil { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "GetBlockUserById", err) + return resp, errors.WrapError(constant.ErrDB) + } + resp.BlockUser = &pbUser.BlockUser{ + User: &pbUser.User{ + ProfilePhoto: user.User.FaceURL, + Nickname: user.User.Nickname, + UserId: user.User.UserID, + IsBlock: true, + }, + BeginDisableTime: (user.BeginDisableTime).String(), + EndDisableTime: (user.EndDisableTime).String(), + } + return resp, nil +} + +func (s *userServer) DeleteUser(_ context.Context, req *pbUser.DeleteUserReq) (*pbUser.DeleteUserResp, error) { + log.NewInfo(req.OperationID, utils.GetSelfFuncName(), req.String()) + resp := &pbUser.DeleteUserResp{} + if row := imdb.DeleteUser(req.UserId); row == 0 { + log.NewError(req.OperationID, utils.GetSelfFuncName(), "delete failed", "delete rows:", row) + return resp, errors.WrapError(constant.ErrDB) + } + return resp, nil +} diff --git a/pkg/cms_api_struct/admin.go b/pkg/cms_api_struct/admin.go new file mode 100644 index 000000000..54674662e --- /dev/null +++ b/pkg/cms_api_struct/admin.go @@ -0,0 +1,10 @@ +package cms_api_struct + +type AdminLoginRequest struct { + AdminName string `json:"admin_name" binding:"required"` + Secret string `json:"secret" binding:"required"` +} + +type AdminLoginResponse struct { + Token string `json:"token"` +} \ No newline at end of file diff --git a/pkg/cms_api_struct/common.go b/pkg/cms_api_struct/common.go new file mode 100644 index 000000000..7d160f543 --- /dev/null +++ b/pkg/cms_api_struct/common.go @@ -0,0 +1,11 @@ +package cms_api_struct + +type RequestPagination struct { + PageNumber int `form:"page_number" binding:"required"` + ShowNumber int `form:"show_number" binding:"required"` +} + +type ResponsePagination struct { + CurrentPage int `json:"current_number" binding:"required"` + ShowNumber int `json:"show_number" binding:"required"` +} \ No newline at end of file diff --git a/pkg/cms_api_struct/group.go b/pkg/cms_api_struct/group.go new file mode 100644 index 000000000..9d161b622 --- /dev/null +++ b/pkg/cms_api_struct/group.go @@ -0,0 +1,146 @@ +package cms_api_struct + +type GroupResponse struct { + GroupName string `json:"group_name"` + GroupID string `json:"group_id"` + GroupMasterName string `json:"group_master_name"` + GroupMasterId string `json:"group_master_id"` + CreateTime string `json:"create_time"` + IsBanChat bool `json:"is_ban_chat"` + IsBanPrivateChat bool `json:"is_ban_private_chat"` + ProfilePhoto string `json:"profile_photo"` +} + +type GetGroupByIdRequest struct { + GroupId string `form:"group_id" binding:"required"` +} + +type GetGroupByIdResponse struct { + GroupResponse +} + +type GetGroupRequest struct { + GroupName string `form:"group_name" binding:"required"` + RequestPagination +} + +type GetGroupResponse struct { + Groups []GroupResponse `json:"groups"` + GroupNums int `json:"group_nums"` + ResponsePagination +} + +type GetGroupsRequest struct { + RequestPagination +} + +type GetGroupsResponse struct { + Groups []GroupResponse `json:"groups"` + GroupNums int `json:"group_nums"` + ResponsePagination +} + +type CreateGroupRequest struct { + GroupName string `json:"group_name" binding:"required"` + GroupMasterId string `json:"group_master_id" binding:"required"` + GroupMembers []string `json:"group_members" binding:"required"` +} + +type CreateGroupResponse struct { +} + +type SetGroupMasterRequest struct { + GroupId string `json:"group_id" binding:"required"` + UserId string `json:"user_id" binding:"required"` +} + +type SetGroupMasterResponse struct { +} + +type SetGroupMemberRequest struct { + GroupId string `json:"group_id" binding:"required"` + UserId string `json:"user_id" binding:"required"` +} + +type SetGroupMemberRespones struct { + +} + +type BanGroupChatRequest struct { + GroupId string `json:"group_id" binding:"required"` +} + +type BanGroupChatResponse struct { +} + +type BanPrivateChatRequest struct { + GroupId string `json:"group_id" binding:"required"` +} + +type BanPrivateChatResponse struct { +} + +type DeleteGroupRequest struct { + GroupId string `json:"group_id" binding:"required"` +} + +type DeleteGroupResponse struct { +} + +type GetGroupMembersRequest struct { + GroupId string `form:"group_id" binding:"required"` + UserName string `form:"user_name"` + RequestPagination +} + +type GroupMemberResponse struct { + MemberPosition int `json:"member_position"` + MemberNickName string `json:"member_nick_name"` + MemberId string `json:"member_id"` + JoinTime string `json:"join_time"` +} + +type GetGroupMembersResponse struct { + GroupMembers []GroupMemberResponse `json:"group_members"` + ResponsePagination + MemberNums int `json:"member_nums"` +} + +type GroupMemberRequest struct { + GroupId string `json:"group_id" binding:"required"` + Members []string `json:"members" binding:"required"` +} + +type GroupMemberOperateResponse struct { + Success []string `json:"success"` + Failed []string `json:"failed"` +} + +type AddGroupMembersRequest struct { + GroupMemberRequest +} + +type AddGroupMembersResponse struct { + GroupMemberOperateResponse +} + +type RemoveGroupMembersRequest struct { + GroupMemberRequest +} + +type RemoveGroupMembersResponse struct{ + GroupMemberOperateResponse +} + +type AlterGroupInfoRequest struct { + GroupID string `json:"group_id"` + GroupName string `json:"group_name"` + Notification string `json:"notification"` + Introduction string `json:"introduction"` + ProfilePhoto string `json:"profile_photo"` + GroupType int `json:"group_type"` +} + +type AlterGroupInfoResponse struct { + +} diff --git a/pkg/cms_api_struct/message_cms.go b/pkg/cms_api_struct/message_cms.go new file mode 100644 index 000000000..bbf62c3ec --- /dev/null +++ b/pkg/cms_api_struct/message_cms.go @@ -0,0 +1,48 @@ +package cms_api_struct + +type BroadcastRequest struct { + Message string `json:"message"` +} + +type BroadcastResponse struct { +} + +type MassSendMassageRequest struct { +} + +type MassSendMassageResponse struct { +} + +type GetChatLogsRequest struct { + SessionType int `form:"session_type"` + ContentType int `form:"content_type"` + Content string `form:"content"` + UserId string `form:"user_id"` + GroupId string `form:"group_id"` + Date string `form:"date"` + + RequestPagination +} + +type ChatLog struct { + SessionType int `json:"session_type"` + ContentType int `json:"content_type"` + SenderNickName string `json:"sender_nick_name"` + SenderId int `json:"sender_id"` + SearchContent string `json:"search_content"` + WholeContent string `json:"whole_content"` + + ReceiverNickName string `json:"receiver_nick_name"` + ReceiverID int `json:"receiver_id"` + + GroupName string `json:"group_name"` + GroupId string `json:"group_id"` + + Date string `json:"date"` +} + +type GetChatLogsResponse struct { + ChatLogs []ChatLog `json:"chat_logs"` + logNums int `json:"log_nums"` + ResponsePagination +} diff --git a/pkg/cms_api_struct/organization.go b/pkg/cms_api_struct/organization.go new file mode 100644 index 000000000..825d41aa1 --- /dev/null +++ b/pkg/cms_api_struct/organization.go @@ -0,0 +1,25 @@ +package cms_api_struct + +type GetStaffsResponse struct { + StaffsList []struct { + ProfilePhoto string `json:"profile_photo"` + NickName string `json:"nick_name"` + StaffId int `json:"staff_id"` + Position string `json:"position"` + EntryTime string `json:"entry_time"` + } `json:"staffs_list"` +} + +type GetOrganizationsResponse struct { + OrganizationList []struct { + OrganizationId int `json:"organization_id"` + OrganizationName string `json:"organization_name"` + } `json:"organization_list"` +} + +type SquadResponse struct { + SquadList []struct { + SquadId int `json:"squad_id"` + SquadName string `json:"squad_name"` + } `json:"squad_list"` +} diff --git a/pkg/cms_api_struct/statistics.go b/pkg/cms_api_struct/statistics.go new file mode 100644 index 000000000..2ff1efffa --- /dev/null +++ b/pkg/cms_api_struct/statistics.go @@ -0,0 +1,89 @@ +package cms_api_struct + +type GetStatisticsRequest struct { + From string `form:"from" binding:"required"` + To string `form:"to" binding:"required"` +} + +type GetMessageStatisticsRequest struct { + GetStatisticsRequest +} + +type GetMessageStatisticsResponse struct { + PrivateMessageNum int `json:"private_message_num"` + GroupMessageNum int `json:"group_message_num"` + PrivateMessageNumList []struct { + Date string `json:"date"` + MessageNum int `json:"message_num"` + } `json:"private_message_num_list"` + GroupMessageNumList []struct { + Date string `json:"date"` + MessageNum int `json:"message_num"` + } `json:"group_message_num_list"` +} + +type GetUserStatisticsRequest struct { + GetStatisticsRequest +} + +type GetUserStatisticsResponse struct { + IncreaseUserNum int `json:"increase_user_num"` + ActiveUserNum int `json:"active_user_num"` + TotalUserNum int `json:"total_user_num"` + IncreaseUserNumList []struct { + Date string `json:"date"` + IncreaseUserNum int `json:"increase_user_num"` + } `json:"increase_user_num_list"` + ActiveUserNumList []struct { + Date string `json:"date"` + ActiveUserNum int `json:"active_user_num"` + } `json:"active_user_num_list"` + TotalUserNumList []struct { + Date string `json:"date"` + TotalUserNum int `json:"total_user_num"` + } `json:"total_user_num_list"` +} + +type GetGroupStatisticsRequest struct { + GetStatisticsRequest +} + +// 群聊统计 +type GetGroupStatisticsResponse struct { + IncreaseGroupNum int `json:"increase_group_num"` + TotalGroupNum int `json:"total_group_num"` + IncreaseGroupNumList []struct { + Date string `json:"date"` + IncreaseGroupNum int `json:"increase_group_num"` + } `json:"increase_group_num_list"` + TotalGroupNumList []struct { + Date string `json:"date"` + TotalGroupNum int `json:"total_group_num"` + } `json:"total_group_num_list"` +} + +type GetActiveUserRequest struct { + GetStatisticsRequest + // RequestPagination +} + +type GetActiveUserResponse struct { + ActiveUserList []struct { + NickName string `json:"nick_name"` + UserId string `json:"user_id"` + MessageNum int `json:"message_num"` + } `json:"active_user_list"` +} + +type GetActiveGroupRequest struct { + GetStatisticsRequest + // RequestPagination +} + +type GetActiveGroupResponse struct { + ActiveGroupList []struct { + GroupName string `json:"group_name"` + GroupId string `json:"group_id"` + MessageNum int `json:"message_num"` + } `json:"active_group_list"` +} diff --git a/pkg/cms_api_struct/user.go b/pkg/cms_api_struct/user.go new file mode 100644 index 000000000..2c0b004b0 --- /dev/null +++ b/pkg/cms_api_struct/user.go @@ -0,0 +1,110 @@ +package cms_api_struct + +type UserResponse struct { + ProfilePhoto string `json:"profile_photo"` + Nickname string `json:"nick_name"` + UserId string `json:"user_id"` + CreateTime string `json:"create_time,omitempty"` + IsBlock bool `json:"is_block"` +} + +type GetUserRequest struct { + UserId string `form:"user_id" binding:"required"` +} + +type GetUserResponse struct { + UserResponse +} + +type GetUsersRequest struct { + RequestPagination +} + +type GetUsersResponse struct { + Users []*UserResponse `json:"users"` + ResponsePagination + UserNums int32 `json:"user_nums"` +} + +type GetUsersByNameRequest struct { + UserName string `form:"user_name" binding:"required"` + RequestPagination +} + +type GetUsersByNameResponse struct { + Users []*UserResponse `json:"users"` + ResponsePagination + UserNums int32 `json:"user_nums"` +} + +type ResignUserRequest struct { + UserId string `json:"user_id"` +} + +type ResignUserResponse struct { +} + +type AlterUserRequest struct { + UserId string `json:"user_id" binding:"required"` + Nickname string `json:"nickname"` + PhoneNumber int `json:"phone_number" validate:"len=11"` + Email string `json:"email"` +} + +type AlterUserResponse struct { +} + +type AddUserRequest struct { + PhoneNumber string `json:"phone_number" binding:"required"` + UserId string `json:"user_id" binding:"required"` + Name string `json:"name" binding:"required"` +} + +type AddUserResponse struct { +} + +type BlockUser struct { + UserResponse + BeginDisableTime string `json:"begin_disable_time"` + EndDisableTime string `json:"end_disable_time"` +} + +type BlockUserRequest struct { + UserId string `json:"user_id" binding:"required"` + EndDisableTime string `json:"end_disable_time" binding:"required"` +} + +type BlockUserResponse struct { +} + +type UnblockUserRequest struct { + UserId string `json:"user_id" binding:"required"` +} + +type UnBlockUserResponse struct { +} + +type GetBlockUsersRequest struct { + RequestPagination +} + +type GetBlockUsersResponse struct { + BlockUsers []BlockUser `json:"block_users"` + ResponsePagination + UserNums int32 `json:"user_nums"` +} + +type GetBlockUserRequest struct { + UserId string `form:"user_id" binding:"required"` +} + +type GetBlockUserResponse struct { + BlockUser +} + +type DeleteUserRequest struct { + UserId string `json:"user_id" binding:"required"` +} + +type DeleteUserResponse struct { +} diff --git a/pkg/common/config/config.go b/pkg/common/config/config.go index b2079acf3..3d5f245d9 100644 --- a/pkg/common/config/config.go +++ b/pkg/common/config/config.go @@ -77,6 +77,7 @@ type config struct { RpcGetTokenPort []int `yaml:"rpcGetTokenPort"` } RpcRegisterName struct { + OpenImStatisticsName string `yaml:"OpenImStatisticsName"` OpenImUserName string `yaml:"openImUserName"` OpenImFriendName string `yaml:"openImFriendName"` OpenImOfflineMessageName string `yaml:"openImOfflineMessageName"` @@ -84,6 +85,8 @@ type config struct { OpenImOnlineMessageRelayName string `yaml:"openImOnlineMessageRelayName"` OpenImGroupName string `yaml:"openImGroupName"` OpenImAuthName string `yaml:"openImAuthName"` + OpenImMessageCMSName string `yaml:"openImMessageCMSName"` + OpenImAdminCMSName string `yaml:"openImAdminCMSName"` } Etcd struct { EtcdSchema string `yaml:"etcdSchema"` diff --git a/pkg/common/constant/constant.go b/pkg/common/constant/constant.go index 81e124476..741f0beea 100644 --- a/pkg/common/constant/constant.go +++ b/pkg/common/constant/constant.go @@ -109,6 +109,16 @@ const ( IsUnreadCount = "unreadCount" IsConversationUpdate = "conversationUpdate" IsSenderSync = "senderSync" + + //GroupStatus + GroupOk = 0 + GroupBanChat = 1 + GroupDisband = 2 + GroupBaned = 3 + GroupBanPrivateChat = 4 + + //UserJoinGroupSource + JoinByAdmin = 1 ) var ContentType2PushContent = map[int64]string{ @@ -147,3 +157,17 @@ const ( ) const FriendAcceptTip = "You have successfully become friends, so start chatting" + +func GroupIsBanChat(status int32) bool { + if status != GroupBanChat { + return false + } + return true +} + +func GroupIsBanPrivateChat(status int32) bool { + if status != GroupBanPrivateChat { + return false + } + return true +} diff --git a/pkg/common/constant/error.go b/pkg/common/constant/error.go index 86d1359c3..923d0bbd8 100644 --- a/pkg/common/constant/error.go +++ b/pkg/common/constant/error.go @@ -10,11 +10,12 @@ type ErrInfo struct { var ( OK = ErrInfo{0, ""} + ErrServer = ErrInfo{500, "server error"} // ErrMysql = ErrInfo{100, ""} // ErrMongo = ErrInfo{110, ""} // ErrRedis = ErrInfo{120, ""} - ErrParseToken = ErrInfo{200, ParseTokenMsg.Error()} + ErrParseToken = ErrInfo{700, ParseTokenMsg.Error()} // ErrCreateToken = ErrInfo{201, "Create token failed"} // ErrAppServerKey = ErrInfo{300, "key error"} ErrTencentCredential = ErrInfo{400, ThirdPartyMsg.Error()} @@ -86,6 +87,10 @@ const ( IntentionalError = 10007 ) -func (e *ErrInfo) Error() string { +func (e ErrInfo) Error() string { return e.ErrMsg } + +func (e *ErrInfo) Code() int32 { + return e.ErrCode +} diff --git a/pkg/common/db/model_struct.go b/pkg/common/db/model_struct.go index a1d003714..9381717df 100644 --- a/pkg/common/db/model_struct.go +++ b/pkg/common/db/model_struct.go @@ -193,3 +193,9 @@ type ChatLog struct { CreateTime time.Time `gorm:"column:create_time" json:"createTime"` Ex string `gorm:"column:ex;type:varchar(1024)" json:"ex"` } + +type BlackList struct { + UserId string `gorm:"column:uid"` + BeginDisableTime time.Time `gorm:"column:begin_disable_time"` + EndDisableTime time.Time `gorm:"column:end_disable_time"` +} diff --git a/pkg/common/db/mysql.go b/pkg/common/db/mysql.go index d41f676a0..1b48bfb93 100644 --- a/pkg/common/db/mysql.go +++ b/pkg/common/db/mysql.go @@ -4,10 +4,11 @@ import ( "Open_IM/pkg/common/config" "Open_IM/pkg/common/log" "fmt" - "github.com/jinzhu/gorm" - _ "github.com/jinzhu/gorm/dialects/mysql" "sync" "time" + + "github.com/jinzhu/gorm" + _ "github.com/jinzhu/gorm/dialects/mysql" ) type mysqlDB struct { diff --git a/pkg/common/db/mysql_model/im_mysql_model/group_member_model.go b/pkg/common/db/mysql_model/im_mysql_model/group_member_model.go index e2d6a1db2..4dafa30a6 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/group_member_model.go +++ b/pkg/common/db/mysql_model/im_mysql_model/group_member_model.go @@ -4,6 +4,7 @@ import ( "Open_IM/pkg/common/constant" "Open_IM/pkg/common/db" "Open_IM/pkg/utils" + "fmt" "time" ) @@ -225,6 +226,31 @@ func IsGroupOwnerAdmin(groupID, UserID string) bool { return false } +func GetGroupMembersByGroupIdCMS(groupId string, userName string, showNumber, pageNumber int32) ([]db.GroupMember, error) { + var groupMembers []db.GroupMember + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return groupMembers, err + } + err = dbConn.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groupMembers).Error + if err != nil { + return nil, err + } + return groupMembers, nil +} + +func GetGroupMembersCount(groupId, userName string) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var count int32 + if err != nil { + return count, err + } + dbConn.LogMode(true) + if err := dbConn.Table("group_members").Where("group_id=?", groupId).Where(fmt.Sprintf(" nickname like '%%%s%%' ", userName)).Count(&count).Error; err != nil { + return count, err + } + return count, nil +} // //func SelectGroupList(groupID string) ([]string, error) { diff --git a/pkg/common/db/mysql_model/im_mysql_model/group_model.go b/pkg/common/db/mysql_model/im_mysql_model/group_model.go index 60b470685..a1e8318fd 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/group_model.go +++ b/pkg/common/db/mysql_model/im_mysql_model/group_model.go @@ -1,8 +1,11 @@ package im_mysql_model import ( + "Open_IM/pkg/common/constant" "Open_IM/pkg/common/db" "Open_IM/pkg/utils" + "errors" + "fmt" "time" ) @@ -53,6 +56,126 @@ func SetGroupInfo(groupInfo db.Group) error { if err != nil { return err } + dbConn.LogMode(true) err = dbConn.Table("groups").Where("group_id=?", groupInfo.GroupID).Update(&groupInfo).Error return err } + +func GetGroupsByName(groupName string, pageNumber, showNumber int32) ([]db.Group, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var groups []db.Group + if err != nil { + return groups, err + } + dbConn.LogMode(true) + err = dbConn.Table("groups").Where(fmt.Sprintf(" name like '%%%s%%' ", groupName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groups).Error + return groups, err +} + +func GetGroups(pageNumber, showNumber int) ([]db.Group, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var groups []db.Group + if err != nil { + return groups, err + } + dbConn.LogMode(true) + if err = dbConn.Table("groups").Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&groups).Error; err != nil { + return groups, err + } + return groups, nil +} + + +func OperateGroupStatus(groupId string, groupStatus int32) error { + group := db.Group{ + GroupID: groupId, + Status: groupStatus, + } + if err := SetGroupInfo(group); err != nil { + return err + } + return nil +} + + +func DeleteGroup(groupId string) error { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return err + } + dbConn.LogMode(true) + var group db.Group + var groupMembers []db.GroupMember + if err := dbConn.Table("groups").Where("group_id=?", groupId).Delete(&group).Error; err != nil { + return err + } + if err := dbConn.Table("group_members").Where("group_id=?", groupId).Delete(groupMembers).Error; err != nil { + return err + } + return nil +} + +func OperateGroupRole(userId, groupId string, roleLevel int32) error { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return err + } + dbConn.LogMode(true) + groupMember := db.GroupMember{ + UserID: userId, + GroupID: groupId, + RoleLevel: roleLevel, + } + updateInfo := db.GroupMember{ + RoleLevel: roleLevel, + } + result := dbConn.Table("group_members").Find(&groupMember).Update(updateInfo) + if result.Error != nil { + return result.Error + } + if result.RowsAffected == 0 { + return errors.New(fmt.Sprintf("user %s not exist in group %s or already operate", userId, groupId)) + } + return nil +} + +func GetGroupsCountNum(group db.Group) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var count int32 + if err := dbConn.Table("groups").Where(fmt.Sprintf(" name like '%%%s%%' ", group.GroupName)).Count(&count).Error; err != nil { + return 0, err + } + return count, nil +} + +func GetGroupById(groupId string) (db.Group, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + group := db.Group{ + GroupID: groupId, + } + if err != nil { + return group, err + } + dbConn.LogMode(true) + if err := dbConn.Table("groups").Find(&group).Error; err != nil { + return group, err + } + return group, nil +} + +func GetGroupMaster(groupId string) (db.GroupMember, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + groupMember := db.GroupMember{} + if err != nil { + return groupMember, err + } + dbConn.LogMode(true) + if err := dbConn.Table("group_members").Where("role_level=? and group_id=?", constant.GroupOwner, groupId).Find(&groupMember).Error; err != nil { + return groupMember, err + } + return groupMember, nil +} \ No newline at end of file diff --git a/pkg/common/db/mysql_model/im_mysql_model/message_cms.go b/pkg/common/db/mysql_model/im_mysql_model/message_cms.go new file mode 100644 index 000000000..0f289a048 --- /dev/null +++ b/pkg/common/db/mysql_model/im_mysql_model/message_cms.go @@ -0,0 +1,29 @@ +package im_mysql_model + +import ( + "Open_IM/pkg/common/db" + "fmt" +) + +func GetChatLog(chatLog db.ChatLog, pageNumber, showNumber int32) ([]db.ChatLog, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var chatLogs []db.ChatLog + if err != nil { + return chatLogs, err + } + dbConn.LogMode(true) + err = dbConn.Table("chat_logs").Where(fmt.Sprintf(" content like '%%%s%%'", chatLog.Content)). + Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&chatLogs).Error + return chatLogs, err +} + +func GetChatLogCount(chatLog db.ChatLog) (int64, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var count int64 + if err != nil { + return count, err + } + dbConn.LogMode(true) + err = dbConn.Table("chat_logs").Where(fmt.Sprintf(" content like '%%%s%%' and ", chatLog.Content)).Count(&count).Error + return count, err +} \ No newline at end of file diff --git a/pkg/common/db/mysql_model/im_mysql_model/statistics_model.go b/pkg/common/db/mysql_model/im_mysql_model/statistics_model.go new file mode 100644 index 000000000..ae2ec9cfd --- /dev/null +++ b/pkg/common/db/mysql_model/im_mysql_model/statistics_model.go @@ -0,0 +1,153 @@ +package im_mysql_model + +import ( + "Open_IM/pkg/common/db" + "time" +) + +func GetActiveUserNum(from, to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("chat_logs").Select("count(distinct(send_id))").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error + return num, err +} + +func GetIncreaseUserNum(from, to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("users").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error + return num, err +} + +func GetTotalUserNum() (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("users").Count(&num).Error + return num, err +} + +func GetTotalUserNumByDate(to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("users").Where("create_time <= ?", to).Count(&num).Error + return num, err +} + +func GetPrivateMessageNum(from, to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Count(&num).Error + return num, err +} + +func GetGroupMessageNum(from, to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("chat_logs").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Count(&num).Error + return num, err +} + +func GetIncreaseGroupNum(from, to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("groups").Where("create_time >= ? and create_time <= ?", from, to).Count(&num).Error + return num, err +} + +func GetTotalGroupNum() (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("groups").Count(&num).Error + return num, err +} + +func GetGroupNum(to time.Time) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var num int32 + err = dbConn.Table("groups").Where("create_time <= ?", to).Count(&num).Error + return num, err +} + +type activeGroup struct { + Name string + Id string `gorm:"column:recv_id"` + MessageNum int `gorm:"column:message_num"` +} + +func GetActiveGroups(from, to time.Time, limit int) ([]*activeGroup, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var activeGroups []*activeGroup + if err != nil { + return activeGroups, err + } + dbConn.LogMode(true) + err = dbConn.Table("chat_logs").Select("recv_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 2).Group("recv_id").Limit(limit).Order("message_num DESC").Find(&activeGroups).Error + for _, activeGroup := range activeGroups { + group := db.Group{ + GroupID: activeGroup.Id, + } + dbConn.Model(&group).Select("group_id", "name").Find(&group) + activeGroup.Name = group.GroupName + } + return activeGroups, err +} + +type activeUser struct { + Name string + Id string `gorm:"column:send_id"` + MessageNum int `gorm:"column:message_num"` +} + +func GetActiveUsers(from, to time.Time, limit int) ([]*activeUser, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var activeUsers []*activeUser + if err != nil { + return activeUsers, err + } + dbConn.LogMode(true) + err = dbConn.Table("chat_logs").Select("send_id, count(*) as message_num").Where("create_time >= ? and create_time <= ? and session_type = ?", from, to, 1).Group("send_id").Limit(limit).Order("message_num DESC").Find(&activeUsers).Error + for _, activeUser := range activeUsers { + user := db.User{ + UserID: activeUser.Id, + } + dbConn.Table("users").Select("user_id, name").Find(&user) + activeUser.Name = user.Nickname + } + return activeUsers, err +} diff --git a/pkg/common/db/mysql_model/im_mysql_model/user_model.go b/pkg/common/db/mysql_model/im_mysql_model/user_model.go index 5c3b226d5..de5045855 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/user_model.go +++ b/pkg/common/db/mysql_model/im_mysql_model/user_model.go @@ -6,8 +6,9 @@ import ( "Open_IM/pkg/common/db" "Open_IM/pkg/utils" "fmt" - _ "github.com/jinzhu/gorm/dialects/mysql" "time" + + _ "github.com/jinzhu/gorm/dialects/mysql" ) func init() { @@ -50,17 +51,17 @@ func UserRegister(user db.User) error { return nil } -//type User struct { -// UserID string `gorm:"column:user_id;primaryKey;"` -// Nickname string `gorm:"column:name"` -// FaceUrl string `gorm:"column:icon"` -// Gender int32 `gorm:"column:gender"` -// PhoneNumber string `gorm:"column:phone_number"` -// Birth string `gorm:"column:birth"` -// Email string `gorm:"column:email"` -// Ex string `gorm:"column:ex"` -// CreateTime time.Time `gorm:"column:create_time"` -//} +type User struct { + UserID string `gorm:"column:user_id;primaryKey;"` + Nickname string `gorm:"column:name"` + FaceUrl string `gorm:"column:icon"` + Gender int32 `gorm:"column:gender"` + PhoneNumber string `gorm:"column:phone_number"` + Birth string `gorm:"column:birth"` + Email string `gorm:"column:email"` + Ex string `gorm:"column:ex"` + CreateTime time.Time `gorm:"column:create_time"` +} func DeleteUser(userID string) (i int64) { dbConn, err := db.DB.MysqlDB.DefaultGormDB() @@ -89,7 +90,7 @@ func UpdateUserInfo(user db.User) error { if err != nil { return err } - + dbConn.LogMode(true) err = dbConn.Table("users").Where("user_id=?", user.UserID).Update(&user).Error return err } @@ -121,3 +122,184 @@ func SelectSomeUserID(userIDList []string) ([]string, error) { } return resultArr, nil } + +func GetUsers(showNumber, pageNumber int32) ([]db.User, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var users []db.User + if err != nil { + return users, err + } + dbConn.LogMode(true) + err = dbConn.Table("users").Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error + if err != nil { + return users, err + } + return users, err +} + +func AddUser(userId, phoneNumber, name string) error { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return err + } + user := db.User{ + PhoneNumber: phoneNumber, + Birth: time.Now(), + CreateTime: time.Now(), + UserID: userId, + Nickname: name, + } + result := dbConn.Table("users").Create(&user) + return result.Error +} + +func UserIsBlock(userId string) (bool, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return false, err + } + var user db.BlackList + rows := dbConn.Table("black_lists").Where("uid=?", userId).First(&user).RowsAffected + if rows >= 1 { + return true, nil + } + return false, nil +} + +func BlockUser(userId, endDisableTime string) error { + user, err := GetUserByUserID(userId) + if err != nil || user.UserID == "" { + return err + } + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return err + } + end, err := time.Parse("2006-01-02 15:04:05", endDisableTime) + if err != nil { + return err + } + if end.Before(time.Now()) { + return constant.ErrDB + } + var blockUser db.BlackList + dbConn.Table("black_lists").Where("uid=?", userId).First(&blockUser) + if blockUser.UserId != "" { + dbConn.Model(&blockUser).Where("uid=?", blockUser.UserId).Update("end_disable_time", end) + return nil + } + blockUser = db.BlackList{ + UserId: userId, + BeginDisableTime: time.Now(), + EndDisableTime: end, + } + result := dbConn.Create(&blockUser) + return result.Error +} + +func UnBlockUser(userId string) error { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return err + } + dbConn.LogMode(true) + result := dbConn.Where("uid=?", userId).Delete(&db.BlackList{}) + return result.Error +} + +type BlockUserInfo struct { + User db.User + BeginDisableTime time.Time + EndDisableTime time.Time +} + +func GetBlockUserById(userId string) (BlockUserInfo, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var blockUserInfo BlockUserInfo + blockUser := db.BlackList{ + UserId: userId, + } + if err != nil { + return blockUserInfo, err + } + if err = dbConn.Table("black_lists").Where("uid=?", userId).Find(&blockUser).Error; err != nil { + return blockUserInfo, err + } + user := db.User{ + UserID: blockUser.UserId, + } + if err := dbConn.Find(&user).Error; err != nil { + return blockUserInfo, err + } + blockUserInfo.User.UserID = user.UserID + blockUserInfo.User.FaceURL = user.UserID + blockUserInfo.User.Nickname = user.Nickname + blockUserInfo.BeginDisableTime = blockUser.BeginDisableTime + blockUserInfo.EndDisableTime = blockUser.EndDisableTime + return blockUserInfo, nil +} + +func GetBlockUsers(showNumber, pageNumber int32) ([]BlockUserInfo, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var blockUserInfos []BlockUserInfo + var blockUsers []db.BlackList + if err != nil { + return blockUserInfos, err + } + dbConn.LogMode(true) + if err = dbConn.Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&blockUsers).Error; err != nil { + return blockUserInfos, err + } + for _, blockUser := range blockUsers { + var user db.User + if err := dbConn.Table("users").Where("user_id=?", blockUser.UserId).First(&user).Error; err == nil { + blockUserInfos = append(blockUserInfos, BlockUserInfo{ + User: db.User{ + UserID: user.UserID, + Nickname: user.Nickname, + FaceURL: user.FaceURL, + }, + BeginDisableTime: blockUser.BeginDisableTime, + EndDisableTime: blockUser.EndDisableTime, + }) + } + } + return blockUserInfos, nil +} + +func GetUserByName(userName string, showNumber, pageNumber int32) ([]db.User, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + var users []db.User + if err != nil { + return users, err + } + dbConn.LogMode(true) + err = dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", userName)).Limit(showNumber).Offset(showNumber * (pageNumber - 1)).Find(&users).Error + return users, err +} + +func GetUsersCount(user db.User) (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var count int32 + if err := dbConn.Table("users").Where(fmt.Sprintf(" name like '%%%s%%' ", user.Nickname)).Count(&count).Error; err != nil { + return 0, err + } + return count, nil +} + +func GetBlockUsersNumCount() (int32, error) { + dbConn, err := db.DB.MysqlDB.DefaultGormDB() + if err != nil { + return 0, err + } + dbConn.LogMode(true) + var count int32 + if err := dbConn.Model(&db.BlackList{}).Count(&count).Error; err != nil { + return 0, err + } + return count, nil +} diff --git a/pkg/common/http/http_resp.go b/pkg/common/http/http_resp.go new file mode 100644 index 000000000..cdbf04463 --- /dev/null +++ b/pkg/common/http/http_resp.go @@ -0,0 +1,43 @@ +package http + +import ( + "Open_IM/pkg/common/constant" + "fmt" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + //"Open_IM/pkg/cms_api_struct" + "net/http" + + "github.com/gin-gonic/gin" +) + +type BaseResp struct { + Code int32 `json:"code"` + ErrMsg string `json:"err_msg"` + Data interface{} `json:"data"` +} + +func RespHttp200(ctx *gin.Context, err error, data interface{}) { + var resp BaseResp + switch e := err.(type) { + case constant.ErrInfo: + resp.Code = e.ErrCode + resp.ErrMsg = e.ErrMsg + default: + s, ok := status.FromError(err) + if !ok { + fmt.Println("need grpc format error") + return + } + resp.Code = int32(s.Code()) + resp.ErrMsg = s.Message() + } + resp.Data = data + ctx.JSON(http.StatusOK, resp) +} + +// warp error +func WrapError(err constant.ErrInfo) error { + return status.Error(codes.Code(err.ErrCode), err.ErrMsg) +} diff --git a/pkg/common/log/logrus.go b/pkg/common/log/logrus.go index 936f3e9b2..e8a4ba25f 100644 --- a/pkg/common/log/logrus.go +++ b/pkg/common/log/logrus.go @@ -2,14 +2,14 @@ package log import ( "Open_IM/pkg/common/config" - "bufio" "fmt" + "os" + "time" + nested "github.com/antonfisher/nested-logrus-formatter" rotatelogs "github.com/lestrrat-go/file-rotatelogs" "github.com/rifflock/lfshook" "github.com/sirupsen/logrus" - "os" - "time" ) var logger *Logger @@ -32,12 +32,13 @@ func loggerInit(moduleName string) *Logger { //All logs will be printed logger.SetLevel(logrus.Level(config.Config.Log.RemainLogLevel)) //Close std console output - src, err := os.OpenFile(os.DevNull, os.O_APPEND|os.O_WRONLY, os.ModeAppend) - if err != nil { - panic(err.Error()) - } - writer := bufio.NewWriter(src) - logger.SetOutput(writer) + // src, err := os.OpenFile(os.DevNull, os.O_APPEND|os.O_WRONLY, os.ModeAppend) + // if err != nil { + // panic(err.Error()) + // } + // writer := bufio.NewWriter(src) + // logger.SetOutput(writer) + logger.SetOutput(os.Stdout) //Log Console Print Style Setting logger.SetFormatter(&nested.Formatter{ TimestampFormat: "2006-01-02 15:04:05.000", diff --git a/pkg/proto/admin_cms/admin_cms.pb.go b/pkg/proto/admin_cms/admin_cms.pb.go new file mode 100644 index 000000000..890f409a9 --- /dev/null +++ b/pkg/proto/admin_cms/admin_cms.pb.go @@ -0,0 +1,317 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.15.5 +// source: admin_cms/admin_cms.proto + +package admin_cms + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type AdminLoginReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OperationID string `protobuf:"bytes,1,opt,name=OperationID,proto3" json:"OperationID,omitempty"` + AdminID string `protobuf:"bytes,2,opt,name=AdminID,proto3" json:"AdminID,omitempty"` + Secret string `protobuf:"bytes,3,opt,name=Secret,proto3" json:"Secret,omitempty"` +} + +func (x *AdminLoginReq) Reset() { + *x = AdminLoginReq{} + if protoimpl.UnsafeEnabled { + mi := &file_admin_cms_admin_cms_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AdminLoginReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdminLoginReq) ProtoMessage() {} + +func (x *AdminLoginReq) ProtoReflect() protoreflect.Message { + mi := &file_admin_cms_admin_cms_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdminLoginReq.ProtoReflect.Descriptor instead. +func (*AdminLoginReq) Descriptor() ([]byte, []int) { + return file_admin_cms_admin_cms_proto_rawDescGZIP(), []int{0} +} + +func (x *AdminLoginReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +func (x *AdminLoginReq) GetAdminID() string { + if x != nil { + return x.AdminID + } + return "" +} + +func (x *AdminLoginReq) GetSecret() string { + if x != nil { + return x.Secret + } + return "" +} + +type AdminLoginResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"` +} + +func (x *AdminLoginResp) Reset() { + *x = AdminLoginResp{} + if protoimpl.UnsafeEnabled { + mi := &file_admin_cms_admin_cms_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AdminLoginResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AdminLoginResp) ProtoMessage() {} + +func (x *AdminLoginResp) ProtoReflect() protoreflect.Message { + mi := &file_admin_cms_admin_cms_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AdminLoginResp.ProtoReflect.Descriptor instead. +func (*AdminLoginResp) Descriptor() ([]byte, []int) { + return file_admin_cms_admin_cms_proto_rawDescGZIP(), []int{1} +} + +func (x *AdminLoginResp) GetToken() string { + if x != nil { + return x.Token + } + return "" +} + +var File_admin_cms_admin_cms_proto protoreflect.FileDescriptor + +var file_admin_cms_admin_cms_proto_rawDesc = []byte{ + 0x0a, 0x19, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6d, 0x73, 0x2f, 0x61, 0x64, 0x6d, 0x69, + 0x6e, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x61, 0x64, 0x6d, + 0x69, 0x6e, 0x5f, 0x63, 0x6d, 0x73, 0x22, 0x63, 0x0a, 0x0d, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x4c, + 0x6f, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x41, 0x64, 0x6d, + 0x69, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x41, 0x64, 0x6d, 0x69, + 0x6e, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x06, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x22, 0x26, 0x0a, 0x0e, 0x41, + 0x64, 0x6d, 0x69, 0x6e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x14, 0x0a, + 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, + 0x6b, 0x65, 0x6e, 0x32, 0x4d, 0x0a, 0x08, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x43, 0x4d, 0x53, 0x12, + 0x41, 0x0a, 0x0a, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x12, 0x18, 0x2e, + 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x4c, + 0x6f, 0x67, 0x69, 0x6e, 0x52, 0x65, 0x71, 0x1a, 0x19, 0x2e, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x5f, + 0x63, 0x6d, 0x73, 0x2e, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x4c, 0x6f, 0x67, 0x69, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x42, 0x17, 0x5a, 0x15, 0x2e, 0x2f, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6d, + 0x73, 0x3b, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x5f, 0x63, 0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_admin_cms_admin_cms_proto_rawDescOnce sync.Once + file_admin_cms_admin_cms_proto_rawDescData = file_admin_cms_admin_cms_proto_rawDesc +) + +func file_admin_cms_admin_cms_proto_rawDescGZIP() []byte { + file_admin_cms_admin_cms_proto_rawDescOnce.Do(func() { + file_admin_cms_admin_cms_proto_rawDescData = protoimpl.X.CompressGZIP(file_admin_cms_admin_cms_proto_rawDescData) + }) + return file_admin_cms_admin_cms_proto_rawDescData +} + +var file_admin_cms_admin_cms_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_admin_cms_admin_cms_proto_goTypes = []interface{}{ + (*AdminLoginReq)(nil), // 0: admin_cms.AdminLoginReq + (*AdminLoginResp)(nil), // 1: admin_cms.AdminLoginResp +} +var file_admin_cms_admin_cms_proto_depIdxs = []int32{ + 0, // 0: admin_cms.adminCMS.AdminLogin:input_type -> admin_cms.AdminLoginReq + 1, // 1: admin_cms.adminCMS.AdminLogin:output_type -> admin_cms.AdminLoginResp + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_admin_cms_admin_cms_proto_init() } +func file_admin_cms_admin_cms_proto_init() { + if File_admin_cms_admin_cms_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_admin_cms_admin_cms_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AdminLoginReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_admin_cms_admin_cms_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AdminLoginResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_admin_cms_admin_cms_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_admin_cms_admin_cms_proto_goTypes, + DependencyIndexes: file_admin_cms_admin_cms_proto_depIdxs, + MessageInfos: file_admin_cms_admin_cms_proto_msgTypes, + }.Build() + File_admin_cms_admin_cms_proto = out.File + file_admin_cms_admin_cms_proto_rawDesc = nil + file_admin_cms_admin_cms_proto_goTypes = nil + file_admin_cms_admin_cms_proto_depIdxs = nil +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConnInterface + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion6 + +// AdminCMSClient is the client API for AdminCMS service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type AdminCMSClient interface { + AdminLogin(ctx context.Context, in *AdminLoginReq, opts ...grpc.CallOption) (*AdminLoginResp, error) +} + +type adminCMSClient struct { + cc grpc.ClientConnInterface +} + +func NewAdminCMSClient(cc grpc.ClientConnInterface) AdminCMSClient { + return &adminCMSClient{cc} +} + +func (c *adminCMSClient) AdminLogin(ctx context.Context, in *AdminLoginReq, opts ...grpc.CallOption) (*AdminLoginResp, error) { + out := new(AdminLoginResp) + err := c.cc.Invoke(ctx, "/admin_cms.adminCMS/AdminLogin", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// AdminCMSServer is the server API for AdminCMS service. +type AdminCMSServer interface { + AdminLogin(context.Context, *AdminLoginReq) (*AdminLoginResp, error) +} + +// UnimplementedAdminCMSServer can be embedded to have forward compatible implementations. +type UnimplementedAdminCMSServer struct { +} + +func (*UnimplementedAdminCMSServer) AdminLogin(context.Context, *AdminLoginReq) (*AdminLoginResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method AdminLogin not implemented") +} + +func RegisterAdminCMSServer(s *grpc.Server, srv AdminCMSServer) { + s.RegisterService(&_AdminCMS_serviceDesc, srv) +} + +func _AdminCMS_AdminLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AdminLoginReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(AdminCMSServer).AdminLogin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/admin_cms.adminCMS/AdminLogin", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(AdminCMSServer).AdminLogin(ctx, req.(*AdminLoginReq)) + } + return interceptor(ctx, in, info, handler) +} + +var _AdminCMS_serviceDesc = grpc.ServiceDesc{ + ServiceName: "admin_cms.adminCMS", + HandlerType: (*AdminCMSServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "AdminLogin", + Handler: _AdminCMS_AdminLogin_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "admin_cms/admin_cms.proto", +} diff --git a/pkg/proto/admin_cms/admin_cms.proto b/pkg/proto/admin_cms/admin_cms.proto new file mode 100644 index 000000000..6759268ed --- /dev/null +++ b/pkg/proto/admin_cms/admin_cms.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; +option go_package = "./admin_cms;admin_cms"; +package admin_cms; + +message AdminLoginReq { + string OperationID = 1; + string AdminID = 2; + string Secret = 3; +} + + +message AdminLoginResp { + string token = 1; +} + +service adminCMS { + rpc AdminLogin(AdminLoginReq) returns(AdminLoginResp); +} \ No newline at end of file diff --git a/pkg/proto/group/group.pb.go b/pkg/proto/group/group.pb.go index 352023544..54a10cdf4 100644 --- a/pkg/proto/group/group.pb.go +++ b/pkg/proto/group/group.pb.go @@ -2120,6 +2120,1143 @@ func (x *GetGroupAllMemberResp) GetMemberList() []*sdk_ws.GroupMemberFullInfo { return nil } +type CMSGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupInfo *sdk_ws.GroupInfo `protobuf:"bytes,1,opt,name=GroupInfo,proto3" json:"GroupInfo,omitempty"` + GroupMasterName string `protobuf:"bytes,2,opt,name=GroupMasterName,proto3" json:"GroupMasterName,omitempty"` + GroupMasterId string `protobuf:"bytes,3,opt,name=GroupMasterId,proto3" json:"GroupMasterId,omitempty"` +} + +func (x *CMSGroup) Reset() { + *x = CMSGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CMSGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CMSGroup) ProtoMessage() {} + +func (x *CMSGroup) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[33] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CMSGroup.ProtoReflect.Descriptor instead. +func (*CMSGroup) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{33} +} + +func (x *CMSGroup) GetGroupInfo() *sdk_ws.GroupInfo { + if x != nil { + return x.GroupInfo + } + return nil +} + +func (x *CMSGroup) GetGroupMasterName() string { + if x != nil { + return x.GroupMasterName + } + return "" +} + +func (x *CMSGroup) GetGroupMasterId() string { + if x != nil { + return x.GroupMasterId + } + return "" +} + +type GetGroupReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupName string `protobuf:"bytes,1,opt,name=GroupName,proto3" json:"GroupName,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupReq) Reset() { + *x = GetGroupReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupReq) ProtoMessage() {} + +func (x *GetGroupReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupReq.ProtoReflect.Descriptor instead. +func (*GetGroupReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{34} +} + +func (x *GetGroupReq) GetGroupName() string { + if x != nil { + return x.GroupName + } + return "" +} + +func (x *GetGroupReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetGroupResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CMSGroups []*CMSGroup `protobuf:"bytes,1,rep,name=CMSGroups,proto3" json:"CMSGroups,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + GroupNums int32 `protobuf:"varint,3,opt,name=GroupNums,proto3" json:"GroupNums,omitempty"` +} + +func (x *GetGroupResp) Reset() { + *x = GetGroupResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupResp) ProtoMessage() {} + +func (x *GetGroupResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[35] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupResp.ProtoReflect.Descriptor instead. +func (*GetGroupResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{35} +} + +func (x *GetGroupResp) GetCMSGroups() []*CMSGroup { + if x != nil { + return x.CMSGroups + } + return nil +} + +func (x *GetGroupResp) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupResp) GetGroupNums() int32 { + if x != nil { + return x.GroupNums + } + return 0 +} + +type GetGroupsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,1,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupsReq) Reset() { + *x = GetGroupsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupsReq) ProtoMessage() {} + +func (x *GetGroupsReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[36] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupsReq.ProtoReflect.Descriptor instead. +func (*GetGroupsReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{36} +} + +func (x *GetGroupsReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupsReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetGroupsResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CMSGroups []*CMSGroup `protobuf:"bytes,1,rep,name=CMSGroups,proto3" json:"CMSGroups,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + GroupNum int32 `protobuf:"varint,3,opt,name=GroupNum,proto3" json:"GroupNum,omitempty"` +} + +func (x *GetGroupsResp) Reset() { + *x = GetGroupsResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupsResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupsResp) ProtoMessage() {} + +func (x *GetGroupsResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[37] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupsResp.ProtoReflect.Descriptor instead. +func (*GetGroupsResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{37} +} + +func (x *GetGroupsResp) GetCMSGroups() []*CMSGroup { + if x != nil { + return x.CMSGroups + } + return nil +} + +func (x *GetGroupsResp) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupsResp) GetGroupNum() int32 { + if x != nil { + return x.GroupNum + } + return 0 +} + +type GetGroupMemberReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupMemberReq) Reset() { + *x = GetGroupMemberReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupMemberReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupMemberReq) ProtoMessage() {} + +func (x *GetGroupMemberReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupMemberReq.ProtoReflect.Descriptor instead. +func (*GetGroupMemberReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{38} +} + +func (x *GetGroupMemberReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *GetGroupMemberReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type OperateGroupStatusReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + Status int32 `protobuf:"varint,2,opt,name=Status,proto3" json:"Status,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *OperateGroupStatusReq) Reset() { + *x = OperateGroupStatusReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateGroupStatusReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateGroupStatusReq) ProtoMessage() {} + +func (x *OperateGroupStatusReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[39] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateGroupStatusReq.ProtoReflect.Descriptor instead. +func (*OperateGroupStatusReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{39} +} + +func (x *OperateGroupStatusReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *OperateGroupStatusReq) GetStatus() int32 { + if x != nil { + return x.Status + } + return 0 +} + +func (x *OperateGroupStatusReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type OperateGroupStatusResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *OperateGroupStatusResp) Reset() { + *x = OperateGroupStatusResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateGroupStatusResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateGroupStatusResp) ProtoMessage() {} + +func (x *OperateGroupStatusResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[40] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateGroupStatusResp.ProtoReflect.Descriptor instead. +func (*OperateGroupStatusResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{40} +} + +type OperateUserRoleReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + UserId string `protobuf:"bytes,2,opt,name=UserId,proto3" json:"UserId,omitempty"` + RoleLevel int32 `protobuf:"varint,3,opt,name=RoleLevel,proto3" json:"RoleLevel,omitempty"` + OperationID string `protobuf:"bytes,4,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *OperateUserRoleReq) Reset() { + *x = OperateUserRoleReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateUserRoleReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateUserRoleReq) ProtoMessage() {} + +func (x *OperateUserRoleReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[41] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateUserRoleReq.ProtoReflect.Descriptor instead. +func (*OperateUserRoleReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{41} +} + +func (x *OperateUserRoleReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *OperateUserRoleReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *OperateUserRoleReq) GetRoleLevel() int32 { + if x != nil { + return x.RoleLevel + } + return 0 +} + +func (x *OperateUserRoleReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type OperateUserRoleResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *OperateUserRoleResp) Reset() { + *x = OperateUserRoleResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OperateUserRoleResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OperateUserRoleResp) ProtoMessage() {} + +func (x *OperateUserRoleResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[42] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OperateUserRoleResp.ProtoReflect.Descriptor instead. +func (*OperateUserRoleResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{42} +} + +type DeleteGroupReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *DeleteGroupReq) Reset() { + *x = DeleteGroupReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteGroupReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteGroupReq) ProtoMessage() {} + +func (x *DeleteGroupReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[43] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteGroupReq.ProtoReflect.Descriptor instead. +func (*DeleteGroupReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{43} +} + +func (x *DeleteGroupReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *DeleteGroupReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type DeleteGroupResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteGroupResp) Reset() { + *x = DeleteGroupResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteGroupResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteGroupResp) ProtoMessage() {} + +func (x *DeleteGroupResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[44] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteGroupResp.ProtoReflect.Descriptor instead. +func (*DeleteGroupResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{44} +} + +type GetGroupByIdReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupByIdReq) Reset() { + *x = GetGroupByIdReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupByIdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupByIdReq) ProtoMessage() {} + +func (x *GetGroupByIdReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[45] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupByIdReq.ProtoReflect.Descriptor instead. +func (*GetGroupByIdReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{45} +} + +func (x *GetGroupByIdReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *GetGroupByIdReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetGroupByIdResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CMSGroup *CMSGroup `protobuf:"bytes,1,opt,name=CMSGroup,proto3" json:"CMSGroup,omitempty"` +} + +func (x *GetGroupByIdResp) Reset() { + *x = GetGroupByIdResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupByIdResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupByIdResp) ProtoMessage() {} + +func (x *GetGroupByIdResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[46] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupByIdResp.ProtoReflect.Descriptor instead. +func (*GetGroupByIdResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{46} +} + +func (x *GetGroupByIdResp) GetCMSGroup() *CMSGroup { + if x != nil { + return x.CMSGroup + } + return nil +} + +type GetGroupMembersCMSReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + UserName string `protobuf:"bytes,2,opt,name=UserName,proto3" json:"UserName,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,3,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,4,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupMembersCMSReq) Reset() { + *x = GetGroupMembersCMSReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupMembersCMSReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupMembersCMSReq) ProtoMessage() {} + +func (x *GetGroupMembersCMSReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[47] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupMembersCMSReq.ProtoReflect.Descriptor instead. +func (*GetGroupMembersCMSReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{47} +} + +func (x *GetGroupMembersCMSReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *GetGroupMembersCMSReq) GetUserName() string { + if x != nil { + return x.UserName + } + return "" +} + +func (x *GetGroupMembersCMSReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupMembersCMSReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetGroupMembersCMSResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Members []*sdk_ws.GroupMemberFullInfo `protobuf:"bytes,1,rep,name=members,proto3" json:"members,omitempty"` + Pagination *sdk_ws.ResponsePagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + MemberNums int32 `protobuf:"varint,3,opt,name=MemberNums,proto3" json:"MemberNums,omitempty"` +} + +func (x *GetGroupMembersCMSResp) Reset() { + *x = GetGroupMembersCMSResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupMembersCMSResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupMembersCMSResp) ProtoMessage() {} + +func (x *GetGroupMembersCMSResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[48] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupMembersCMSResp.ProtoReflect.Descriptor instead. +func (*GetGroupMembersCMSResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{48} +} + +func (x *GetGroupMembersCMSResp) GetMembers() []*sdk_ws.GroupMemberFullInfo { + if x != nil { + return x.Members + } + return nil +} + +func (x *GetGroupMembersCMSResp) GetPagination() *sdk_ws.ResponsePagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetGroupMembersCMSResp) GetMemberNums() int32 { + if x != nil { + return x.MemberNums + } + return 0 +} + +type RemoveGroupMembersCMSReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + UserIds []string `protobuf:"bytes,2,rep,name=UserIds,proto3" json:"UserIds,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *RemoveGroupMembersCMSReq) Reset() { + *x = RemoveGroupMembersCMSReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RemoveGroupMembersCMSReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RemoveGroupMembersCMSReq) ProtoMessage() {} + +func (x *RemoveGroupMembersCMSReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[49] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RemoveGroupMembersCMSReq.ProtoReflect.Descriptor instead. +func (*RemoveGroupMembersCMSReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{49} +} + +func (x *RemoveGroupMembersCMSReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *RemoveGroupMembersCMSReq) GetUserIds() []string { + if x != nil { + return x.UserIds + } + return nil +} + +func (x *RemoveGroupMembersCMSReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type RemoveGroupMembersCMSResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Success []string `protobuf:"bytes,1,rep,name=success,proto3" json:"success,omitempty"` + Failed []string `protobuf:"bytes,2,rep,name=failed,proto3" json:"failed,omitempty"` +} + +func (x *RemoveGroupMembersCMSResp) Reset() { + *x = RemoveGroupMembersCMSResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RemoveGroupMembersCMSResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RemoveGroupMembersCMSResp) ProtoMessage() {} + +func (x *RemoveGroupMembersCMSResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[50] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RemoveGroupMembersCMSResp.ProtoReflect.Descriptor instead. +func (*RemoveGroupMembersCMSResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{50} +} + +func (x *RemoveGroupMembersCMSResp) GetSuccess() []string { + if x != nil { + return x.Success + } + return nil +} + +func (x *RemoveGroupMembersCMSResp) GetFailed() []string { + if x != nil { + return x.Failed + } + return nil +} + +type AddGroupMembersCMSReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupId string `protobuf:"bytes,1,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + UserIds []string `protobuf:"bytes,2,rep,name=UserIds,proto3" json:"UserIds,omitempty"` + OperationId string `protobuf:"bytes,3,opt,name=OperationId,proto3" json:"OperationId,omitempty"` +} + +func (x *AddGroupMembersCMSReq) Reset() { + *x = AddGroupMembersCMSReq{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddGroupMembersCMSReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddGroupMembersCMSReq) ProtoMessage() {} + +func (x *AddGroupMembersCMSReq) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[51] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddGroupMembersCMSReq.ProtoReflect.Descriptor instead. +func (*AddGroupMembersCMSReq) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{51} +} + +func (x *AddGroupMembersCMSReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *AddGroupMembersCMSReq) GetUserIds() []string { + if x != nil { + return x.UserIds + } + return nil +} + +func (x *AddGroupMembersCMSReq) GetOperationId() string { + if x != nil { + return x.OperationId + } + return "" +} + +type AddGroupMembersCMSResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Success []string `protobuf:"bytes,1,rep,name=success,proto3" json:"success,omitempty"` + Failed []string `protobuf:"bytes,2,rep,name=failed,proto3" json:"failed,omitempty"` +} + +func (x *AddGroupMembersCMSResp) Reset() { + *x = AddGroupMembersCMSResp{} + if protoimpl.UnsafeEnabled { + mi := &file_group_group_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddGroupMembersCMSResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddGroupMembersCMSResp) ProtoMessage() {} + +func (x *AddGroupMembersCMSResp) ProtoReflect() protoreflect.Message { + mi := &file_group_group_proto_msgTypes[52] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddGroupMembersCMSResp.ProtoReflect.Descriptor instead. +func (*AddGroupMembersCMSResp) Descriptor() ([]byte, []int) { + return file_group_group_proto_rawDescGZIP(), []int{52} +} + +func (x *AddGroupMembersCMSResp) GetSuccess() []string { + if x != nil { + return x.Success + } + return nil +} + +func (x *AddGroupMembersCMSResp) GetFailed() []string { + if x != nil { + return x.Failed + } + return nil +} + var File_group_group_proto protoreflect.FileDescriptor var file_group_group_proto_rawDesc = []byte{ @@ -2397,83 +3534,256 @@ var file_group_group_proto_rawDesc = []byte{ 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x6d, 0x65, 0x6d, - 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x32, 0xa2, 0x09, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x12, 0x3c, 0x0a, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x12, 0x15, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x16, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, - 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, - 0x36, 0x0a, 0x09, 0x6a, 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x13, 0x2e, 0x67, - 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, - 0x71, 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, 0x0a, 0x09, 0x71, 0x75, 0x69, 0x74, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x12, 0x13, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x51, 0x75, 0x69, - 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x2e, 0x51, 0x75, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, - 0x42, 0x0a, 0x0d, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x17, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x67, 0x72, 0x6f, 0x75, - 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x65, 0x73, 0x70, 0x12, 0x3f, 0x0a, 0x0c, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x17, 0x2e, 0x67, 0x72, - 0x6f, 0x75, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x65, 0x73, 0x70, 0x12, 0x60, 0x0a, 0x17, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x12, - 0x21, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, - 0x65, 0x71, 0x1a, 0x22, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x66, 0x0a, 0x19, 0x67, 0x65, 0x74, 0x55, 0x73, 0x65, - 0x72, 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, - 0x69, 0x73, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x55, - 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x24, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, - 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, - 0x0a, 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, - 0x77, 0x6e, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x54, 0x72, 0x61, - 0x6e, 0x73, 0x66, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, - 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, - 0x66, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, - 0x70, 0x12, 0x63, 0x0a, 0x18, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x2e, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x65, - 0x71, 0x1a, 0x23, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, - 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x2e, 0x67, - 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, - 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, - 0x72, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x54, 0x0a, 0x13, 0x67, 0x65, 0x74, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, - 0x1e, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, - 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x12, - 0x48, 0x0a, 0x0f, 0x6b, 0x69, 0x63, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, - 0x65, 0x72, 0x12, 0x19, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4b, 0x69, 0x63, 0x6b, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x1a, 0x2e, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4b, 0x69, 0x63, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, - 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x67, 0x65, 0x74, - 0x4a, 0x6f, 0x69, 0x6e, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x12, - 0x1c, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x69, 0x6e, 0x65, - 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x69, 0x6e, 0x65, 0x64, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4e, 0x0a, 0x11, - 0x69, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x12, 0x1b, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, - 0x55, 0x73, 0x65, 0x72, 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x1c, - 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x55, 0x73, 0x65, - 0x72, 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4e, 0x0a, 0x11, - 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6c, 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, - 0x72, 0x12, 0x1b, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x41, 0x6c, 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x1c, + 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x96, 0x01, 0x0a, 0x08, 0x43, 0x4d, 0x53, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3a, 0x0a, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, + 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x28, 0x0a, 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0d, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64, + 0x22, 0x93, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, + 0x12, 0x1c, 0x0a, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44, + 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xa1, 0x01, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2d, 0x0a, 0x09, 0x43, 0x4d, 0x53, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x09, 0x43, 0x4d, 0x53, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x73, 0x22, 0x76, 0x0a, 0x0c, 0x47, 0x65, + 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x22, 0xa0, 0x01, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x2d, 0x0a, 0x09, 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, + 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x09, 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x22, 0x4f, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x6b, 0x0a, 0x15, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x12, + 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x22, 0x18, 0x0a, 0x16, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x22, 0x86, 0x01, + 0x0a, 0x12, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, + 0x65, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x16, + 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x52, 0x6f, 0x6c, 0x65, 0x4c, 0x65, + 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x52, 0x6f, 0x6c, 0x65, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x15, 0x0a, 0x13, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x4c, 0x0a, + 0x0e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x12, + 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x11, 0x0a, 0x0f, 0x44, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x22, 0x4d, + 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, + 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x3f, 0x0a, + 0x10, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x2b, 0x0a, 0x08, 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x43, 0x4d, 0x53, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x52, 0x08, 0x43, 0x4d, 0x53, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0xb5, + 0x01, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x49, 0x64, 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x44, + 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xc1, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x40, 0x0a, 0x07, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x6d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, + 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x0a, 0x0a, 0x4d, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, + 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x22, 0x70, 0x0a, 0x18, 0x52, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, + 0x43, 0x4d, 0x53, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, + 0x12, 0x18, 0x0a, 0x07, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x07, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x4d, 0x0a, 0x19, + 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, 0x73, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, + 0x63, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x06, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x22, 0x6d, 0x0a, 0x15, 0x41, + 0x64, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, + 0x53, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x18, + 0x0a, 0x07, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x07, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x4a, 0x0a, 0x16, 0x41, 0x64, + 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x12, 0x16, + 0x0a, 0x06, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x06, + 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x32, 0xad, 0x0e, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x3c, 0x0a, 0x0b, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, + 0x15, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x16, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, + 0x0a, 0x09, 0x6a, 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x13, 0x2e, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, + 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4a, 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x36, 0x0a, 0x09, 0x71, 0x75, 0x69, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x12, 0x13, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x51, 0x75, 0x69, 0x74, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2e, 0x51, 0x75, 0x69, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x42, + 0x0a, 0x0d, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x17, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x3f, 0x0a, 0x0c, 0x73, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x16, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x17, 0x2e, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x53, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x60, 0x0a, 0x17, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x21, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, - 0x6c, 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x42, 0x0f, 0x5a, 0x0d, - 0x2e, 0x2f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x3b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x62, 0x06, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, + 0x71, 0x1a, 0x22, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x66, 0x0a, 0x19, 0x67, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, + 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, + 0x73, 0x74, 0x12, 0x23, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x24, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, + 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, + 0x12, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, + 0x6e, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x54, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, + 0x12, 0x63, 0x0a, 0x18, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x2e, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x52, 0x65, 0x71, + 0x1a, 0x23, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, 0x2e, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x54, 0x0a, 0x13, 0x67, 0x65, 0x74, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x1e, + 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, + 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x12, 0x48, + 0x0a, 0x0f, 0x6b, 0x69, 0x63, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x12, 0x19, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4b, 0x69, 0x63, 0x6b, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x1a, 0x2e, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4b, 0x69, 0x63, 0x6b, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x4a, + 0x6f, 0x69, 0x6e, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1c, + 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x69, 0x6e, 0x65, 0x64, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x69, 0x6e, 0x65, 0x64, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4e, 0x0a, 0x11, 0x69, + 0x6e, 0x76, 0x69, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x1b, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x55, + 0x73, 0x65, 0x72, 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x1c, 0x2e, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x49, 0x6e, 0x76, 0x69, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x54, 0x6f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4e, 0x0a, 0x11, 0x67, + 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6c, 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x12, 0x1b, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x41, 0x6c, 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x1c, 0x2e, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x6c, + 0x6c, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x3f, 0x0a, 0x0c, 0x47, + 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x49, 0x64, 0x12, 0x16, 0x2e, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x49, 0x64, + 0x52, 0x65, 0x71, 0x1a, 0x17, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x33, 0x0a, 0x08, + 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x12, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x13, 0x2e, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x36, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x12, 0x13, + 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, + 0x52, 0x65, 0x71, 0x1a, 0x14, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x1c, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x48, 0x0a, 0x0f, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x12, + 0x19, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x1a, 0x2e, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x6f, + 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x3c, 0x0a, 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x15, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, 0x16, 0x2e, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, 0x12, 0x1c, 0x2e, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, + 0x43, 0x4d, 0x53, 0x52, 0x65, 0x73, 0x70, 0x12, 0x5a, 0x0a, 0x15, 0x52, 0x65, 0x6d, 0x6f, 0x76, + 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, + 0x12, 0x1f, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, + 0x71, 0x1a, 0x20, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x51, 0x0a, 0x12, 0x41, 0x64, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, + 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, 0x4d, 0x53, 0x12, 0x1c, 0x2e, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x2e, 0x41, 0x64, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, + 0x73, 0x43, 0x4d, 0x53, 0x52, 0x65, 0x71, 0x1a, 0x1d, 0x2e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2e, + 0x41, 0x64, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x43, + 0x4d, 0x53, 0x52, 0x65, 0x73, 0x70, 0x42, 0x0f, 0x5a, 0x0d, 0x2e, 0x2f, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x3b, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -2488,7 +3798,7 @@ func file_group_group_proto_rawDescGZIP() []byte { return file_group_group_proto_rawDescData } -var file_group_group_proto_msgTypes = make([]protoimpl.MessageInfo, 33) +var file_group_group_proto_msgTypes = make([]protoimpl.MessageInfo, 53) var file_group_group_proto_goTypes = []interface{}{ (*CommonResp)(nil), // 0: group.CommonResp (*GroupAddMemberInfo)(nil), // 1: group.GroupAddMemberInfo @@ -2523,65 +3833,116 @@ var file_group_group_proto_goTypes = []interface{}{ (*InviteUserToGroupResp)(nil), // 30: group.InviteUserToGroupResp (*GetGroupAllMemberReq)(nil), // 31: group.GetGroupAllMemberReq (*GetGroupAllMemberResp)(nil), // 32: group.GetGroupAllMemberResp - (*sdk_ws.GroupInfo)(nil), // 33: server_api_params.GroupInfo - (*sdk_ws.GroupRequest)(nil), // 34: server_api_params.GroupRequest - (*sdk_ws.GroupMemberFullInfo)(nil), // 35: server_api_params.GroupMemberFullInfo + (*CMSGroup)(nil), // 33: group.CMSGroup + (*GetGroupReq)(nil), // 34: group.GetGroupReq + (*GetGroupResp)(nil), // 35: group.GetGroupResp + (*GetGroupsReq)(nil), // 36: group.GetGroupsReq + (*GetGroupsResp)(nil), // 37: group.GetGroupsResp + (*GetGroupMemberReq)(nil), // 38: group.GetGroupMemberReq + (*OperateGroupStatusReq)(nil), // 39: group.OperateGroupStatusReq + (*OperateGroupStatusResp)(nil), // 40: group.OperateGroupStatusResp + (*OperateUserRoleReq)(nil), // 41: group.OperateUserRoleReq + (*OperateUserRoleResp)(nil), // 42: group.OperateUserRoleResp + (*DeleteGroupReq)(nil), // 43: group.DeleteGroupReq + (*DeleteGroupResp)(nil), // 44: group.DeleteGroupResp + (*GetGroupByIdReq)(nil), // 45: group.GetGroupByIdReq + (*GetGroupByIdResp)(nil), // 46: group.GetGroupByIdResp + (*GetGroupMembersCMSReq)(nil), // 47: group.GetGroupMembersCMSReq + (*GetGroupMembersCMSResp)(nil), // 48: group.GetGroupMembersCMSResp + (*RemoveGroupMembersCMSReq)(nil), // 49: group.RemoveGroupMembersCMSReq + (*RemoveGroupMembersCMSResp)(nil), // 50: group.RemoveGroupMembersCMSResp + (*AddGroupMembersCMSReq)(nil), // 51: group.AddGroupMembersCMSReq + (*AddGroupMembersCMSResp)(nil), // 52: group.AddGroupMembersCMSResp + (*sdk_ws.GroupInfo)(nil), // 53: server_api_params.GroupInfo + (*sdk_ws.GroupRequest)(nil), // 54: server_api_params.GroupRequest + (*sdk_ws.GroupMemberFullInfo)(nil), // 55: server_api_params.GroupMemberFullInfo + (*sdk_ws.RequestPagination)(nil), // 56: server_api_params.RequestPagination + (*sdk_ws.ResponsePagination)(nil), // 57: server_api_params.ResponsePagination } var file_group_group_proto_depIdxs = []int32{ 1, // 0: group.CreateGroupReq.InitMemberList:type_name -> group.GroupAddMemberInfo - 33, // 1: group.CreateGroupReq.GroupInfo:type_name -> server_api_params.GroupInfo - 33, // 2: group.CreateGroupResp.GroupInfo:type_name -> server_api_params.GroupInfo - 33, // 3: group.GetGroupsInfoResp.GroupInfoList:type_name -> server_api_params.GroupInfo - 33, // 4: group.SetGroupInfoReq.GroupInfo:type_name -> server_api_params.GroupInfo + 53, // 1: group.CreateGroupReq.GroupInfo:type_name -> server_api_params.GroupInfo + 53, // 2: group.CreateGroupResp.GroupInfo:type_name -> server_api_params.GroupInfo + 53, // 3: group.GetGroupsInfoResp.GroupInfoList:type_name -> server_api_params.GroupInfo + 53, // 4: group.SetGroupInfoReq.GroupInfo:type_name -> server_api_params.GroupInfo 0, // 5: group.SetGroupInfoResp.CommonResp:type_name -> group.CommonResp - 34, // 6: group.GetGroupApplicationListResp.GroupRequestList:type_name -> server_api_params.GroupRequest + 54, // 6: group.GetGroupApplicationListResp.GroupRequestList:type_name -> server_api_params.GroupRequest 0, // 7: group.GetUserReqApplicationListResp.CommonResp:type_name -> group.CommonResp - 34, // 8: group.GetUserReqApplicationListResp.GroupRequestList:type_name -> server_api_params.GroupRequest + 54, // 8: group.GetUserReqApplicationListResp.GroupRequestList:type_name -> server_api_params.GroupRequest 0, // 9: group.TransferGroupOwnerResp.CommonResp:type_name -> group.CommonResp 0, // 10: group.JoinGroupResp.CommonResp:type_name -> group.CommonResp 0, // 11: group.GroupApplicationResponseResp.CommonResp:type_name -> group.CommonResp 0, // 12: group.QuitGroupResp.CommonResp:type_name -> group.CommonResp - 35, // 13: group.GetGroupMemberListResp.memberList:type_name -> server_api_params.GroupMemberFullInfo - 35, // 14: group.GetGroupMembersInfoResp.memberList:type_name -> server_api_params.GroupMemberFullInfo + 55, // 13: group.GetGroupMemberListResp.memberList:type_name -> server_api_params.GroupMemberFullInfo + 55, // 14: group.GetGroupMembersInfoResp.memberList:type_name -> server_api_params.GroupMemberFullInfo 25, // 15: group.KickGroupMemberResp.Id2ResultList:type_name -> group.Id2Result - 33, // 16: group.GetJoinedGroupListResp.GroupList:type_name -> server_api_params.GroupInfo + 53, // 16: group.GetJoinedGroupListResp.GroupList:type_name -> server_api_params.GroupInfo 25, // 17: group.InviteUserToGroupResp.Id2ResultList:type_name -> group.Id2Result - 35, // 18: group.GetGroupAllMemberResp.memberList:type_name -> server_api_params.GroupMemberFullInfo - 2, // 19: group.group.createGroup:input_type -> group.CreateGroupReq - 14, // 20: group.group.joinGroup:input_type -> group.JoinGroupReq - 18, // 21: group.group.quitGroup:input_type -> group.QuitGroupReq - 4, // 22: group.group.getGroupsInfo:input_type -> group.GetGroupsInfoReq - 6, // 23: group.group.setGroupInfo:input_type -> group.SetGroupInfoReq - 8, // 24: group.group.getGroupApplicationList:input_type -> group.GetGroupApplicationListReq - 10, // 25: group.group.getUserReqApplicationList:input_type -> group.GetUserReqApplicationListReq - 12, // 26: group.group.transferGroupOwner:input_type -> group.TransferGroupOwnerReq - 16, // 27: group.group.groupApplicationResponse:input_type -> group.GroupApplicationResponseReq - 20, // 28: group.group.getGroupMemberList:input_type -> group.GetGroupMemberListReq - 22, // 29: group.group.getGroupMembersInfo:input_type -> group.GetGroupMembersInfoReq - 24, // 30: group.group.kickGroupMember:input_type -> group.KickGroupMemberReq - 27, // 31: group.group.getJoinedGroupList:input_type -> group.GetJoinedGroupListReq - 29, // 32: group.group.inviteUserToGroup:input_type -> group.InviteUserToGroupReq - 31, // 33: group.group.getGroupAllMember:input_type -> group.GetGroupAllMemberReq - 3, // 34: group.group.createGroup:output_type -> group.CreateGroupResp - 15, // 35: group.group.joinGroup:output_type -> group.JoinGroupResp - 19, // 36: group.group.quitGroup:output_type -> group.QuitGroupResp - 5, // 37: group.group.getGroupsInfo:output_type -> group.GetGroupsInfoResp - 7, // 38: group.group.setGroupInfo:output_type -> group.SetGroupInfoResp - 9, // 39: group.group.getGroupApplicationList:output_type -> group.GetGroupApplicationListResp - 11, // 40: group.group.getUserReqApplicationList:output_type -> group.GetUserReqApplicationListResp - 13, // 41: group.group.transferGroupOwner:output_type -> group.TransferGroupOwnerResp - 17, // 42: group.group.groupApplicationResponse:output_type -> group.GroupApplicationResponseResp - 21, // 43: group.group.getGroupMemberList:output_type -> group.GetGroupMemberListResp - 23, // 44: group.group.getGroupMembersInfo:output_type -> group.GetGroupMembersInfoResp - 26, // 45: group.group.kickGroupMember:output_type -> group.KickGroupMemberResp - 28, // 46: group.group.getJoinedGroupList:output_type -> group.GetJoinedGroupListResp - 30, // 47: group.group.inviteUserToGroup:output_type -> group.InviteUserToGroupResp - 32, // 48: group.group.getGroupAllMember:output_type -> group.GetGroupAllMemberResp - 34, // [34:49] is the sub-list for method output_type - 19, // [19:34] is the sub-list for method input_type - 19, // [19:19] is the sub-list for extension type_name - 19, // [19:19] is the sub-list for extension extendee - 0, // [0:19] is the sub-list for field type_name + 55, // 18: group.GetGroupAllMemberResp.memberList:type_name -> server_api_params.GroupMemberFullInfo + 53, // 19: group.CMSGroup.GroupInfo:type_name -> server_api_params.GroupInfo + 56, // 20: group.GetGroupReq.Pagination:type_name -> server_api_params.RequestPagination + 33, // 21: group.GetGroupResp.CMSGroups:type_name -> group.CMSGroup + 56, // 22: group.GetGroupResp.Pagination:type_name -> server_api_params.RequestPagination + 56, // 23: group.GetGroupsReq.Pagination:type_name -> server_api_params.RequestPagination + 33, // 24: group.GetGroupsResp.CMSGroups:type_name -> group.CMSGroup + 56, // 25: group.GetGroupsResp.Pagination:type_name -> server_api_params.RequestPagination + 33, // 26: group.GetGroupByIdResp.CMSGroup:type_name -> group.CMSGroup + 56, // 27: group.GetGroupMembersCMSReq.Pagination:type_name -> server_api_params.RequestPagination + 55, // 28: group.GetGroupMembersCMSResp.members:type_name -> server_api_params.GroupMemberFullInfo + 57, // 29: group.GetGroupMembersCMSResp.Pagination:type_name -> server_api_params.ResponsePagination + 2, // 30: group.group.createGroup:input_type -> group.CreateGroupReq + 14, // 31: group.group.joinGroup:input_type -> group.JoinGroupReq + 18, // 32: group.group.quitGroup:input_type -> group.QuitGroupReq + 4, // 33: group.group.getGroupsInfo:input_type -> group.GetGroupsInfoReq + 6, // 34: group.group.setGroupInfo:input_type -> group.SetGroupInfoReq + 8, // 35: group.group.getGroupApplicationList:input_type -> group.GetGroupApplicationListReq + 10, // 36: group.group.getUserReqApplicationList:input_type -> group.GetUserReqApplicationListReq + 12, // 37: group.group.transferGroupOwner:input_type -> group.TransferGroupOwnerReq + 16, // 38: group.group.groupApplicationResponse:input_type -> group.GroupApplicationResponseReq + 20, // 39: group.group.getGroupMemberList:input_type -> group.GetGroupMemberListReq + 22, // 40: group.group.getGroupMembersInfo:input_type -> group.GetGroupMembersInfoReq + 24, // 41: group.group.kickGroupMember:input_type -> group.KickGroupMemberReq + 27, // 42: group.group.getJoinedGroupList:input_type -> group.GetJoinedGroupListReq + 29, // 43: group.group.inviteUserToGroup:input_type -> group.InviteUserToGroupReq + 31, // 44: group.group.getGroupAllMember:input_type -> group.GetGroupAllMemberReq + 45, // 45: group.group.GetGroupById:input_type -> group.GetGroupByIdReq + 34, // 46: group.group.GetGroup:input_type -> group.GetGroupReq + 36, // 47: group.group.GetGroups:input_type -> group.GetGroupsReq + 39, // 48: group.group.OperateGroupStatus:input_type -> group.OperateGroupStatusReq + 41, // 49: group.group.OperateUserRole:input_type -> group.OperateUserRoleReq + 43, // 50: group.group.DeleteGroup:input_type -> group.DeleteGroupReq + 47, // 51: group.group.GetGroupMembersCMS:input_type -> group.GetGroupMembersCMSReq + 49, // 52: group.group.RemoveGroupMembersCMS:input_type -> group.RemoveGroupMembersCMSReq + 51, // 53: group.group.AddGroupMembersCMS:input_type -> group.AddGroupMembersCMSReq + 3, // 54: group.group.createGroup:output_type -> group.CreateGroupResp + 15, // 55: group.group.joinGroup:output_type -> group.JoinGroupResp + 19, // 56: group.group.quitGroup:output_type -> group.QuitGroupResp + 5, // 57: group.group.getGroupsInfo:output_type -> group.GetGroupsInfoResp + 7, // 58: group.group.setGroupInfo:output_type -> group.SetGroupInfoResp + 9, // 59: group.group.getGroupApplicationList:output_type -> group.GetGroupApplicationListResp + 11, // 60: group.group.getUserReqApplicationList:output_type -> group.GetUserReqApplicationListResp + 13, // 61: group.group.transferGroupOwner:output_type -> group.TransferGroupOwnerResp + 17, // 62: group.group.groupApplicationResponse:output_type -> group.GroupApplicationResponseResp + 21, // 63: group.group.getGroupMemberList:output_type -> group.GetGroupMemberListResp + 23, // 64: group.group.getGroupMembersInfo:output_type -> group.GetGroupMembersInfoResp + 26, // 65: group.group.kickGroupMember:output_type -> group.KickGroupMemberResp + 28, // 66: group.group.getJoinedGroupList:output_type -> group.GetJoinedGroupListResp + 30, // 67: group.group.inviteUserToGroup:output_type -> group.InviteUserToGroupResp + 32, // 68: group.group.getGroupAllMember:output_type -> group.GetGroupAllMemberResp + 46, // 69: group.group.GetGroupById:output_type -> group.GetGroupByIdResp + 35, // 70: group.group.GetGroup:output_type -> group.GetGroupResp + 37, // 71: group.group.GetGroups:output_type -> group.GetGroupsResp + 40, // 72: group.group.OperateGroupStatus:output_type -> group.OperateGroupStatusResp + 42, // 73: group.group.OperateUserRole:output_type -> group.OperateUserRoleResp + 44, // 74: group.group.DeleteGroup:output_type -> group.DeleteGroupResp + 48, // 75: group.group.GetGroupMembersCMS:output_type -> group.GetGroupMembersCMSResp + 50, // 76: group.group.RemoveGroupMembersCMS:output_type -> group.RemoveGroupMembersCMSResp + 52, // 77: group.group.AddGroupMembersCMS:output_type -> group.AddGroupMembersCMSResp + 54, // [54:78] is the sub-list for method output_type + 30, // [30:54] is the sub-list for method input_type + 30, // [30:30] is the sub-list for extension type_name + 30, // [30:30] is the sub-list for extension extendee + 0, // [0:30] is the sub-list for field type_name } func init() { file_group_group_proto_init() } @@ -2986,6 +4347,246 @@ func file_group_group_proto_init() { return nil } } + file_group_group_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CMSGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupsResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupMemberReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateGroupStatusReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateGroupStatusResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateUserRoleReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OperateUserRoleResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteGroupReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteGroupResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupByIdReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupByIdResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupMembersCMSReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupMembersCMSResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RemoveGroupMembersCMSReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RemoveGroupMembersCMSResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddGroupMembersCMSReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_group_group_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddGroupMembersCMSResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ @@ -2993,7 +4594,7 @@ func file_group_group_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_group_group_proto_rawDesc, NumEnums: 0, - NumMessages: 33, + NumMessages: 53, NumExtensions: 0, NumServices: 1, }, @@ -3034,6 +4635,15 @@ type GroupClient interface { GetJoinedGroupList(ctx context.Context, in *GetJoinedGroupListReq, opts ...grpc.CallOption) (*GetJoinedGroupListResp, error) InviteUserToGroup(ctx context.Context, in *InviteUserToGroupReq, opts ...grpc.CallOption) (*InviteUserToGroupResp, error) GetGroupAllMember(ctx context.Context, in *GetGroupAllMemberReq, opts ...grpc.CallOption) (*GetGroupAllMemberResp, error) + GetGroupById(ctx context.Context, in *GetGroupByIdReq, opts ...grpc.CallOption) (*GetGroupByIdResp, error) + GetGroup(ctx context.Context, in *GetGroupReq, opts ...grpc.CallOption) (*GetGroupResp, error) + GetGroups(ctx context.Context, in *GetGroupsReq, opts ...grpc.CallOption) (*GetGroupsResp, error) + OperateGroupStatus(ctx context.Context, in *OperateGroupStatusReq, opts ...grpc.CallOption) (*OperateGroupStatusResp, error) + OperateUserRole(ctx context.Context, in *OperateUserRoleReq, opts ...grpc.CallOption) (*OperateUserRoleResp, error) + DeleteGroup(ctx context.Context, in *DeleteGroupReq, opts ...grpc.CallOption) (*DeleteGroupResp, error) + GetGroupMembersCMS(ctx context.Context, in *GetGroupMembersCMSReq, opts ...grpc.CallOption) (*GetGroupMembersCMSResp, error) + RemoveGroupMembersCMS(ctx context.Context, in *RemoveGroupMembersCMSReq, opts ...grpc.CallOption) (*RemoveGroupMembersCMSResp, error) + AddGroupMembersCMS(ctx context.Context, in *AddGroupMembersCMSReq, opts ...grpc.CallOption) (*AddGroupMembersCMSResp, error) } type groupClient struct { @@ -3179,6 +4789,87 @@ func (c *groupClient) GetGroupAllMember(ctx context.Context, in *GetGroupAllMemb return out, nil } +func (c *groupClient) GetGroupById(ctx context.Context, in *GetGroupByIdReq, opts ...grpc.CallOption) (*GetGroupByIdResp, error) { + out := new(GetGroupByIdResp) + err := c.cc.Invoke(ctx, "/group.group/GetGroupById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) GetGroup(ctx context.Context, in *GetGroupReq, opts ...grpc.CallOption) (*GetGroupResp, error) { + out := new(GetGroupResp) + err := c.cc.Invoke(ctx, "/group.group/GetGroup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) GetGroups(ctx context.Context, in *GetGroupsReq, opts ...grpc.CallOption) (*GetGroupsResp, error) { + out := new(GetGroupsResp) + err := c.cc.Invoke(ctx, "/group.group/GetGroups", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) OperateGroupStatus(ctx context.Context, in *OperateGroupStatusReq, opts ...grpc.CallOption) (*OperateGroupStatusResp, error) { + out := new(OperateGroupStatusResp) + err := c.cc.Invoke(ctx, "/group.group/OperateGroupStatus", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) OperateUserRole(ctx context.Context, in *OperateUserRoleReq, opts ...grpc.CallOption) (*OperateUserRoleResp, error) { + out := new(OperateUserRoleResp) + err := c.cc.Invoke(ctx, "/group.group/OperateUserRole", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) DeleteGroup(ctx context.Context, in *DeleteGroupReq, opts ...grpc.CallOption) (*DeleteGroupResp, error) { + out := new(DeleteGroupResp) + err := c.cc.Invoke(ctx, "/group.group/DeleteGroup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) GetGroupMembersCMS(ctx context.Context, in *GetGroupMembersCMSReq, opts ...grpc.CallOption) (*GetGroupMembersCMSResp, error) { + out := new(GetGroupMembersCMSResp) + err := c.cc.Invoke(ctx, "/group.group/GetGroupMembersCMS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) RemoveGroupMembersCMS(ctx context.Context, in *RemoveGroupMembersCMSReq, opts ...grpc.CallOption) (*RemoveGroupMembersCMSResp, error) { + out := new(RemoveGroupMembersCMSResp) + err := c.cc.Invoke(ctx, "/group.group/RemoveGroupMembersCMS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *groupClient) AddGroupMembersCMS(ctx context.Context, in *AddGroupMembersCMSReq, opts ...grpc.CallOption) (*AddGroupMembersCMSResp, error) { + out := new(AddGroupMembersCMSResp) + err := c.cc.Invoke(ctx, "/group.group/AddGroupMembersCMS", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // GroupServer is the server API for Group service. type GroupServer interface { CreateGroup(context.Context, *CreateGroupReq) (*CreateGroupResp, error) @@ -3196,6 +4887,15 @@ type GroupServer interface { GetJoinedGroupList(context.Context, *GetJoinedGroupListReq) (*GetJoinedGroupListResp, error) InviteUserToGroup(context.Context, *InviteUserToGroupReq) (*InviteUserToGroupResp, error) GetGroupAllMember(context.Context, *GetGroupAllMemberReq) (*GetGroupAllMemberResp, error) + GetGroupById(context.Context, *GetGroupByIdReq) (*GetGroupByIdResp, error) + GetGroup(context.Context, *GetGroupReq) (*GetGroupResp, error) + GetGroups(context.Context, *GetGroupsReq) (*GetGroupsResp, error) + OperateGroupStatus(context.Context, *OperateGroupStatusReq) (*OperateGroupStatusResp, error) + OperateUserRole(context.Context, *OperateUserRoleReq) (*OperateUserRoleResp, error) + DeleteGroup(context.Context, *DeleteGroupReq) (*DeleteGroupResp, error) + GetGroupMembersCMS(context.Context, *GetGroupMembersCMSReq) (*GetGroupMembersCMSResp, error) + RemoveGroupMembersCMS(context.Context, *RemoveGroupMembersCMSReq) (*RemoveGroupMembersCMSResp, error) + AddGroupMembersCMS(context.Context, *AddGroupMembersCMSReq) (*AddGroupMembersCMSResp, error) } // UnimplementedGroupServer can be embedded to have forward compatible implementations. @@ -3247,6 +4947,33 @@ func (*UnimplementedGroupServer) InviteUserToGroup(context.Context, *InviteUserT func (*UnimplementedGroupServer) GetGroupAllMember(context.Context, *GetGroupAllMemberReq) (*GetGroupAllMemberResp, error) { return nil, status.Errorf(codes.Unimplemented, "method GetGroupAllMember not implemented") } +func (*UnimplementedGroupServer) GetGroupById(context.Context, *GetGroupByIdReq) (*GetGroupByIdResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGroupById not implemented") +} +func (*UnimplementedGroupServer) GetGroup(context.Context, *GetGroupReq) (*GetGroupResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGroup not implemented") +} +func (*UnimplementedGroupServer) GetGroups(context.Context, *GetGroupsReq) (*GetGroupsResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGroups not implemented") +} +func (*UnimplementedGroupServer) OperateGroupStatus(context.Context, *OperateGroupStatusReq) (*OperateGroupStatusResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method OperateGroupStatus not implemented") +} +func (*UnimplementedGroupServer) OperateUserRole(context.Context, *OperateUserRoleReq) (*OperateUserRoleResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method OperateUserRole not implemented") +} +func (*UnimplementedGroupServer) DeleteGroup(context.Context, *DeleteGroupReq) (*DeleteGroupResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteGroup not implemented") +} +func (*UnimplementedGroupServer) GetGroupMembersCMS(context.Context, *GetGroupMembersCMSReq) (*GetGroupMembersCMSResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGroupMembersCMS not implemented") +} +func (*UnimplementedGroupServer) RemoveGroupMembersCMS(context.Context, *RemoveGroupMembersCMSReq) (*RemoveGroupMembersCMSResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveGroupMembersCMS not implemented") +} +func (*UnimplementedGroupServer) AddGroupMembersCMS(context.Context, *AddGroupMembersCMSReq) (*AddGroupMembersCMSResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddGroupMembersCMS not implemented") +} func RegisterGroupServer(s *grpc.Server, srv GroupServer) { s.RegisterService(&_Group_serviceDesc, srv) @@ -3522,6 +5249,168 @@ func _Group_GetGroupAllMember_Handler(srv interface{}, ctx context.Context, dec return interceptor(ctx, in, info, handler) } +func _Group_GetGroupById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGroupByIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).GetGroupById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/GetGroupById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).GetGroupById(ctx, req.(*GetGroupByIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_GetGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGroupReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).GetGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/GetGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).GetGroup(ctx, req.(*GetGroupReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_GetGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGroupsReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).GetGroups(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/GetGroups", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).GetGroups(ctx, req.(*GetGroupsReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_OperateGroupStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(OperateGroupStatusReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).OperateGroupStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/OperateGroupStatus", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).OperateGroupStatus(ctx, req.(*OperateGroupStatusReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_OperateUserRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(OperateUserRoleReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).OperateUserRole(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/OperateUserRole", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).OperateUserRole(ctx, req.(*OperateUserRoleReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_DeleteGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteGroupReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).DeleteGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/DeleteGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).DeleteGroup(ctx, req.(*DeleteGroupReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_GetGroupMembersCMS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGroupMembersCMSReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).GetGroupMembersCMS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/GetGroupMembersCMS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).GetGroupMembersCMS(ctx, req.(*GetGroupMembersCMSReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_RemoveGroupMembersCMS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RemoveGroupMembersCMSReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).RemoveGroupMembersCMS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/RemoveGroupMembersCMS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).RemoveGroupMembersCMS(ctx, req.(*RemoveGroupMembersCMSReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _Group_AddGroupMembersCMS_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddGroupMembersCMSReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GroupServer).AddGroupMembersCMS(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/group.group/AddGroupMembersCMS", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GroupServer).AddGroupMembersCMS(ctx, req.(*AddGroupMembersCMSReq)) + } + return interceptor(ctx, in, info, handler) +} + var _Group_serviceDesc = grpc.ServiceDesc{ ServiceName: "group.group", HandlerType: (*GroupServer)(nil), @@ -3586,6 +5475,42 @@ var _Group_serviceDesc = grpc.ServiceDesc{ MethodName: "getGroupAllMember", Handler: _Group_GetGroupAllMember_Handler, }, + { + MethodName: "GetGroupById", + Handler: _Group_GetGroupById_Handler, + }, + { + MethodName: "GetGroup", + Handler: _Group_GetGroup_Handler, + }, + { + MethodName: "GetGroups", + Handler: _Group_GetGroups_Handler, + }, + { + MethodName: "OperateGroupStatus", + Handler: _Group_OperateGroupStatus_Handler, + }, + { + MethodName: "OperateUserRole", + Handler: _Group_OperateUserRole_Handler, + }, + { + MethodName: "DeleteGroup", + Handler: _Group_DeleteGroup_Handler, + }, + { + MethodName: "GetGroupMembersCMS", + Handler: _Group_GetGroupMembersCMS_Handler, + }, + { + MethodName: "RemoveGroupMembersCMS", + Handler: _Group_RemoveGroupMembersCMS_Handler, + }, + { + MethodName: "AddGroupMembersCMS", + Handler: _Group_AddGroupMembersCMS_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "group/group.proto", diff --git a/pkg/proto/group/group.proto b/pkg/proto/group/group.proto index 80fe16bee..02513d84e 100644 --- a/pkg/proto/group/group.proto +++ b/pkg/proto/group/group.proto @@ -208,6 +208,113 @@ message GetGroupAllMemberResp { repeated server_api_params.GroupMemberFullInfo memberList = 3; } +message CMSGroup { + server_api_params.GroupInfo GroupInfo = 1; + string GroupMasterName = 2; + string GroupMasterId = 3; +} + +message GetGroupReq { + string GroupName = 1; + server_api_params.RequestPagination Pagination = 2; + string OperationID = 3; +} + +message GetGroupResp { + repeated CMSGroup CMSGroups = 1; + server_api_params.RequestPagination Pagination = 2; + int32 GroupNums = 3; +} + +message GetGroupsReq { + server_api_params.RequestPagination Pagination = 1; + string OperationID = 2; +} + +message GetGroupsResp { + repeated CMSGroup CMSGroups = 1; + server_api_params.RequestPagination Pagination = 2; + int32 GroupNum = 3; +} + +message GetGroupMemberReq { + string GroupId = 1; + string OperationID = 2; +} + +message OperateGroupStatusReq { + string GroupId = 1; + int32 Status = 2; + string OperationID = 3; +} + +message OperateGroupStatusResp { + +} + +message OperateUserRoleReq { + string GroupId = 1; + string UserId = 2; + int32 RoleLevel = 3; + string OperationID = 4; +} + +message OperateUserRoleResp { + +} + +message DeleteGroupReq { + string GroupId = 1; + string OperationID = 2; +} + +message DeleteGroupResp { + +} + +message GetGroupByIdReq { + string GroupId = 1; + string OperationID = 2; +} + +message GetGroupByIdResp { + CMSGroup CMSGroup = 1; +} + +message GetGroupMembersCMSReq { + string GroupId = 1; + string UserName = 2; + server_api_params.RequestPagination Pagination = 3; + string OperationID = 4; +} + +message GetGroupMembersCMSResp { + repeated server_api_params.GroupMemberFullInfo members = 1; + server_api_params.ResponsePagination Pagination = 2; + int32 MemberNums = 3; +} + +message RemoveGroupMembersCMSReq { + string GroupId = 1; + repeated string UserIds = 2; + string OperationID = 3; +} + +message RemoveGroupMembersCMSResp { + repeated string success = 1; + repeated string failed = 2; +} + +message AddGroupMembersCMSReq { + string GroupId = 1; + repeated string UserIds = 2; + string OperationId = 3; +} + +message AddGroupMembersCMSResp { + repeated string success = 1; + repeated string failed = 2; +} service group{ @@ -226,6 +333,16 @@ service group{ rpc getJoinedGroupList(GetJoinedGroupListReq) returns (GetJoinedGroupListResp); rpc inviteUserToGroup(InviteUserToGroupReq) returns (InviteUserToGroupResp); rpc getGroupAllMember(GetGroupAllMemberReq) returns(GetGroupAllMemberResp); + + rpc GetGroupById(GetGroupByIdReq) returns(GetGroupByIdResp); + rpc GetGroup(GetGroupReq) returns(GetGroupResp); + rpc GetGroups(GetGroupsReq) returns(GetGroupsResp); + rpc OperateGroupStatus(OperateGroupStatusReq) returns(OperateGroupStatusResp); + rpc OperateUserRole(OperateUserRoleReq) returns(OperateUserRoleResp); + rpc DeleteGroup(DeleteGroupReq) returns(DeleteGroupResp); + rpc GetGroupMembersCMS(GetGroupMembersCMSReq) returns(GetGroupMembersCMSResp); + rpc RemoveGroupMembersCMS(RemoveGroupMembersCMSReq) returns(RemoveGroupMembersCMSResp); + rpc AddGroupMembersCMS(AddGroupMembersCMSReq) returns(AddGroupMembersCMSResp); } diff --git a/pkg/proto/message_cms/message_cms.pb.go b/pkg/proto/message_cms/message_cms.pb.go new file mode 100644 index 000000000..5a6c30d6e --- /dev/null +++ b/pkg/proto/message_cms/message_cms.pb.go @@ -0,0 +1,1073 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.15.5 +// source: message_cms/message_cms.proto + +package message_cms + +import ( + sdk_ws "Open_IM/pkg/proto/sdk_ws" + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type BoradcastMessageReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=Message,proto3" json:"Message,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *BoradcastMessageReq) Reset() { + *x = BoradcastMessageReq{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BoradcastMessageReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BoradcastMessageReq) ProtoMessage() {} + +func (x *BoradcastMessageReq) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BoradcastMessageReq.ProtoReflect.Descriptor instead. +func (*BoradcastMessageReq) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{0} +} + +func (x *BoradcastMessageReq) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *BoradcastMessageReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type BoradcastMessageResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *BoradcastMessageResp) Reset() { + *x = BoradcastMessageResp{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BoradcastMessageResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BoradcastMessageResp) ProtoMessage() {} + +func (x *BoradcastMessageResp) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BoradcastMessageResp.ProtoReflect.Descriptor instead. +func (*BoradcastMessageResp) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{1} +} + +type MassSendMessageReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=Message,proto3" json:"Message,omitempty"` + UserIds []string `protobuf:"bytes,2,rep,name=UserIds,proto3" json:"UserIds,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *MassSendMessageReq) Reset() { + *x = MassSendMessageReq{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MassSendMessageReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MassSendMessageReq) ProtoMessage() {} + +func (x *MassSendMessageReq) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MassSendMessageReq.ProtoReflect.Descriptor instead. +func (*MassSendMessageReq) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{2} +} + +func (x *MassSendMessageReq) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *MassSendMessageReq) GetUserIds() []string { + if x != nil { + return x.UserIds + } + return nil +} + +func (x *MassSendMessageReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type MassSendMessageResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *MassSendMessageResp) Reset() { + *x = MassSendMessageResp{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MassSendMessageResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MassSendMessageResp) ProtoMessage() {} + +func (x *MassSendMessageResp) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MassSendMessageResp.ProtoReflect.Descriptor instead. +func (*MassSendMessageResp) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{3} +} + +type GetChatLogsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Content string `protobuf:"bytes,1,opt,name=Content,proto3" json:"Content,omitempty"` + UserId string `protobuf:"bytes,2,opt,name=UserId,proto3" json:"UserId,omitempty"` + GroupId string `protobuf:"bytes,3,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + Date string `protobuf:"bytes,4,opt,name=Date,proto3" json:"Date,omitempty"` + SessionType int32 `protobuf:"varint,5,opt,name=SessionType,proto3" json:"SessionType,omitempty"` + ContentType int32 `protobuf:"varint,6,opt,name=ContentType,proto3" json:"ContentType,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,7,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,8,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetChatLogsReq) Reset() { + *x = GetChatLogsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetChatLogsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetChatLogsReq) ProtoMessage() {} + +func (x *GetChatLogsReq) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetChatLogsReq.ProtoReflect.Descriptor instead. +func (*GetChatLogsReq) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{4} +} + +func (x *GetChatLogsReq) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *GetChatLogsReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *GetChatLogsReq) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *GetChatLogsReq) GetDate() string { + if x != nil { + return x.Date + } + return "" +} + +func (x *GetChatLogsReq) GetSessionType() int32 { + if x != nil { + return x.SessionType + } + return 0 +} + +func (x *GetChatLogsReq) GetContentType() int32 { + if x != nil { + return x.ContentType + } + return 0 +} + +func (x *GetChatLogsReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetChatLogsReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type ChatLogs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SessionType int32 `protobuf:"varint,1,opt,name=SessionType,proto3" json:"SessionType,omitempty"` + ContentType int32 `protobuf:"varint,2,opt,name=ContentType,proto3" json:"ContentType,omitempty"` + SenderNickName string `protobuf:"bytes,3,opt,name=SenderNickName,proto3" json:"SenderNickName,omitempty"` + SenderId string `protobuf:"bytes,4,opt,name=SenderId,proto3" json:"SenderId,omitempty"` + ReciverNickName string `protobuf:"bytes,5,opt,name=ReciverNickName,proto3" json:"ReciverNickName,omitempty"` + ReciverId string `protobuf:"bytes,6,opt,name=ReciverId,proto3" json:"ReciverId,omitempty"` + SearchContent string `protobuf:"bytes,7,opt,name=SearchContent,proto3" json:"SearchContent,omitempty"` + WholeContent string `protobuf:"bytes,8,opt,name=WholeContent,proto3" json:"WholeContent,omitempty"` + GroupId string `protobuf:"bytes,9,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + GroupName string `protobuf:"bytes,10,opt,name=GroupName,proto3" json:"GroupName,omitempty"` + Date string `protobuf:"bytes,11,opt,name=Date,proto3" json:"Date,omitempty"` +} + +func (x *ChatLogs) Reset() { + *x = ChatLogs{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ChatLogs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ChatLogs) ProtoMessage() {} + +func (x *ChatLogs) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ChatLogs.ProtoReflect.Descriptor instead. +func (*ChatLogs) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{5} +} + +func (x *ChatLogs) GetSessionType() int32 { + if x != nil { + return x.SessionType + } + return 0 +} + +func (x *ChatLogs) GetContentType() int32 { + if x != nil { + return x.ContentType + } + return 0 +} + +func (x *ChatLogs) GetSenderNickName() string { + if x != nil { + return x.SenderNickName + } + return "" +} + +func (x *ChatLogs) GetSenderId() string { + if x != nil { + return x.SenderId + } + return "" +} + +func (x *ChatLogs) GetReciverNickName() string { + if x != nil { + return x.ReciverNickName + } + return "" +} + +func (x *ChatLogs) GetReciverId() string { + if x != nil { + return x.ReciverId + } + return "" +} + +func (x *ChatLogs) GetSearchContent() string { + if x != nil { + return x.SearchContent + } + return "" +} + +func (x *ChatLogs) GetWholeContent() string { + if x != nil { + return x.WholeContent + } + return "" +} + +func (x *ChatLogs) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *ChatLogs) GetGroupName() string { + if x != nil { + return x.GroupName + } + return "" +} + +func (x *ChatLogs) GetDate() string { + if x != nil { + return x.Date + } + return "" +} + +type GetChatLogsResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ChatLogs []*ChatLogs `protobuf:"bytes,1,rep,name=ChatLogs,proto3" json:"ChatLogs,omitempty"` + Pagination *sdk_ws.ResponsePagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` +} + +func (x *GetChatLogsResp) Reset() { + *x = GetChatLogsResp{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetChatLogsResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetChatLogsResp) ProtoMessage() {} + +func (x *GetChatLogsResp) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetChatLogsResp.ProtoReflect.Descriptor instead. +func (*GetChatLogsResp) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{6} +} + +func (x *GetChatLogsResp) GetChatLogs() []*ChatLogs { + if x != nil { + return x.ChatLogs + } + return nil +} + +func (x *GetChatLogsResp) GetPagination() *sdk_ws.ResponsePagination { + if x != nil { + return x.Pagination + } + return nil +} + +type WithdrawMessageReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ServerMsgId string `protobuf:"bytes,1,opt,name=ServerMsgId,proto3" json:"ServerMsgId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *WithdrawMessageReq) Reset() { + *x = WithdrawMessageReq{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawMessageReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawMessageReq) ProtoMessage() {} + +func (x *WithdrawMessageReq) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WithdrawMessageReq.ProtoReflect.Descriptor instead. +func (*WithdrawMessageReq) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{7} +} + +func (x *WithdrawMessageReq) GetServerMsgId() string { + if x != nil { + return x.ServerMsgId + } + return "" +} + +func (x *WithdrawMessageReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type WithdrawMessageResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *WithdrawMessageResp) Reset() { + *x = WithdrawMessageResp{} + if protoimpl.UnsafeEnabled { + mi := &file_message_cms_message_cms_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WithdrawMessageResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WithdrawMessageResp) ProtoMessage() {} + +func (x *WithdrawMessageResp) ProtoReflect() protoreflect.Message { + mi := &file_message_cms_message_cms_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WithdrawMessageResp.ProtoReflect.Descriptor instead. +func (*WithdrawMessageResp) Descriptor() ([]byte, []int) { + return file_message_cms_message_cms_proto_rawDescGZIP(), []int{8} +} + +var File_message_cms_message_cms_proto protoreflect.FileDescriptor + +var file_message_cms_message_cms_proto_rawDesc = []byte{ + 0x0a, 0x1d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x1a, 0x21, 0x4f, 0x70, + 0x65, 0x6e, 0x5f, 0x49, 0x4d, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x73, 0x64, 0x6b, 0x5f, 0x77, 0x73, 0x2f, 0x77, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, + 0x51, 0x0a, 0x13, 0x42, 0x6f, 0x72, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x22, 0x16, 0x0a, 0x14, 0x42, 0x6f, 0x72, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x6a, 0x0a, 0x12, 0x4d, 0x61, + 0x73, 0x73, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, + 0x12, 0x18, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x64, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x15, 0x0a, 0x13, 0x4d, 0x61, 0x73, 0x73, 0x53, 0x65, + 0x6e, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x22, 0x9c, 0x02, + 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, + 0x12, 0x18, 0x0a, 0x07, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, + 0x44, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x61, 0x74, 0x65, + 0x12, 0x20, 0x0a, 0x0b, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, + 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xf0, 0x02, 0x0a, + 0x08, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x53, 0x65, 0x73, + 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x43, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0b, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x26, 0x0a, + 0x0e, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x4e, 0x69, 0x63, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x4e, 0x69, 0x63, + 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x49, + 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x52, 0x65, 0x63, 0x69, 0x76, 0x65, 0x72, 0x4e, 0x69, 0x63, 0x6b, + 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x52, 0x65, 0x63, 0x69, + 0x76, 0x65, 0x72, 0x4e, 0x69, 0x63, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x52, + 0x65, 0x63, 0x69, 0x76, 0x65, 0x72, 0x49, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x52, 0x65, 0x63, 0x69, 0x76, 0x65, 0x72, 0x49, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x53, 0x65, 0x61, + 0x72, 0x63, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, + 0x22, 0x0a, 0x0c, 0x57, 0x68, 0x6f, 0x6c, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, + 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x57, 0x68, 0x6f, 0x6c, 0x65, 0x43, 0x6f, 0x6e, 0x74, + 0x65, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x18, 0x09, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x64, 0x12, 0x1c, 0x0a, + 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x44, + 0x61, 0x74, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x61, 0x74, 0x65, 0x22, + 0x8b, 0x01, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x31, 0x0a, 0x08, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x63, 0x6d, 0x73, 0x2e, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x08, 0x43, 0x68, + 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x58, 0x0a, + 0x12, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4d, 0x73, 0x67, + 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x4d, 0x73, 0x67, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x15, 0x0a, 0x13, 0x57, 0x69, 0x74, 0x68, 0x64, + 0x72, 0x61, 0x77, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x32, 0xdb, + 0x02, 0x0a, 0x0a, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x43, 0x4d, 0x53, 0x12, 0x57, 0x0a, + 0x10, 0x42, 0x6f, 0x72, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x12, 0x20, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, + 0x42, 0x6f, 0x72, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x52, 0x65, 0x71, 0x1a, 0x21, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, + 0x73, 0x2e, 0x42, 0x6f, 0x72, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x54, 0x0a, 0x0f, 0x4d, 0x61, 0x73, 0x73, 0x53, 0x65, + 0x6e, 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x4d, 0x61, 0x73, 0x73, 0x53, 0x65, 0x6e, 0x64, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x20, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x4d, 0x61, 0x73, 0x73, 0x53, 0x65, 0x6e, + 0x64, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x48, 0x0a, 0x0b, + 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x1b, 0x2e, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, + 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x1c, 0x2e, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x74, 0x4c, 0x6f, + 0x67, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x54, 0x0a, 0x0f, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, + 0x61, 0x77, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1f, 0x2e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, 0x77, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x20, 0x2e, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x2e, 0x57, 0x69, 0x74, 0x68, 0x64, 0x72, 0x61, + 0x77, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x42, 0x1b, 0x5a, 0x19, + 0x2e, 0x2f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x3b, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_message_cms_message_cms_proto_rawDescOnce sync.Once + file_message_cms_message_cms_proto_rawDescData = file_message_cms_message_cms_proto_rawDesc +) + +func file_message_cms_message_cms_proto_rawDescGZIP() []byte { + file_message_cms_message_cms_proto_rawDescOnce.Do(func() { + file_message_cms_message_cms_proto_rawDescData = protoimpl.X.CompressGZIP(file_message_cms_message_cms_proto_rawDescData) + }) + return file_message_cms_message_cms_proto_rawDescData +} + +var file_message_cms_message_cms_proto_msgTypes = make([]protoimpl.MessageInfo, 9) +var file_message_cms_message_cms_proto_goTypes = []interface{}{ + (*BoradcastMessageReq)(nil), // 0: message_cms.BoradcastMessageReq + (*BoradcastMessageResp)(nil), // 1: message_cms.BoradcastMessageResp + (*MassSendMessageReq)(nil), // 2: message_cms.MassSendMessageReq + (*MassSendMessageResp)(nil), // 3: message_cms.MassSendMessageResp + (*GetChatLogsReq)(nil), // 4: message_cms.GetChatLogsReq + (*ChatLogs)(nil), // 5: message_cms.ChatLogs + (*GetChatLogsResp)(nil), // 6: message_cms.GetChatLogsResp + (*WithdrawMessageReq)(nil), // 7: message_cms.WithdrawMessageReq + (*WithdrawMessageResp)(nil), // 8: message_cms.WithdrawMessageResp + (*sdk_ws.RequestPagination)(nil), // 9: server_api_params.RequestPagination + (*sdk_ws.ResponsePagination)(nil), // 10: server_api_params.ResponsePagination +} +var file_message_cms_message_cms_proto_depIdxs = []int32{ + 9, // 0: message_cms.GetChatLogsReq.Pagination:type_name -> server_api_params.RequestPagination + 5, // 1: message_cms.GetChatLogsResp.ChatLogs:type_name -> message_cms.ChatLogs + 10, // 2: message_cms.GetChatLogsResp.Pagination:type_name -> server_api_params.ResponsePagination + 0, // 3: message_cms.messageCMS.BoradcastMessage:input_type -> message_cms.BoradcastMessageReq + 2, // 4: message_cms.messageCMS.MassSendMessage:input_type -> message_cms.MassSendMessageReq + 4, // 5: message_cms.messageCMS.GetChatLogs:input_type -> message_cms.GetChatLogsReq + 7, // 6: message_cms.messageCMS.WithdrawMessage:input_type -> message_cms.WithdrawMessageReq + 1, // 7: message_cms.messageCMS.BoradcastMessage:output_type -> message_cms.BoradcastMessageResp + 3, // 8: message_cms.messageCMS.MassSendMessage:output_type -> message_cms.MassSendMessageResp + 6, // 9: message_cms.messageCMS.GetChatLogs:output_type -> message_cms.GetChatLogsResp + 8, // 10: message_cms.messageCMS.WithdrawMessage:output_type -> message_cms.WithdrawMessageResp + 7, // [7:11] is the sub-list for method output_type + 3, // [3:7] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_message_cms_message_cms_proto_init() } +func file_message_cms_message_cms_proto_init() { + if File_message_cms_message_cms_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_message_cms_message_cms_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BoradcastMessageReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BoradcastMessageResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MassSendMessageReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MassSendMessageResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetChatLogsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ChatLogs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetChatLogsResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawMessageReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_message_cms_message_cms_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WithdrawMessageResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_message_cms_message_cms_proto_rawDesc, + NumEnums: 0, + NumMessages: 9, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_message_cms_message_cms_proto_goTypes, + DependencyIndexes: file_message_cms_message_cms_proto_depIdxs, + MessageInfos: file_message_cms_message_cms_proto_msgTypes, + }.Build() + File_message_cms_message_cms_proto = out.File + file_message_cms_message_cms_proto_rawDesc = nil + file_message_cms_message_cms_proto_goTypes = nil + file_message_cms_message_cms_proto_depIdxs = nil +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConnInterface + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion6 + +// MessageCMSClient is the client API for MessageCMS service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MessageCMSClient interface { + BoradcastMessage(ctx context.Context, in *BoradcastMessageReq, opts ...grpc.CallOption) (*BoradcastMessageResp, error) + MassSendMessage(ctx context.Context, in *MassSendMessageReq, opts ...grpc.CallOption) (*MassSendMessageResp, error) + GetChatLogs(ctx context.Context, in *GetChatLogsReq, opts ...grpc.CallOption) (*GetChatLogsResp, error) + WithdrawMessage(ctx context.Context, in *WithdrawMessageReq, opts ...grpc.CallOption) (*WithdrawMessageResp, error) +} + +type messageCMSClient struct { + cc grpc.ClientConnInterface +} + +func NewMessageCMSClient(cc grpc.ClientConnInterface) MessageCMSClient { + return &messageCMSClient{cc} +} + +func (c *messageCMSClient) BoradcastMessage(ctx context.Context, in *BoradcastMessageReq, opts ...grpc.CallOption) (*BoradcastMessageResp, error) { + out := new(BoradcastMessageResp) + err := c.cc.Invoke(ctx, "/message_cms.messageCMS/BoradcastMessage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageCMSClient) MassSendMessage(ctx context.Context, in *MassSendMessageReq, opts ...grpc.CallOption) (*MassSendMessageResp, error) { + out := new(MassSendMessageResp) + err := c.cc.Invoke(ctx, "/message_cms.messageCMS/MassSendMessage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageCMSClient) GetChatLogs(ctx context.Context, in *GetChatLogsReq, opts ...grpc.CallOption) (*GetChatLogsResp, error) { + out := new(GetChatLogsResp) + err := c.cc.Invoke(ctx, "/message_cms.messageCMS/GetChatLogs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *messageCMSClient) WithdrawMessage(ctx context.Context, in *WithdrawMessageReq, opts ...grpc.CallOption) (*WithdrawMessageResp, error) { + out := new(WithdrawMessageResp) + err := c.cc.Invoke(ctx, "/message_cms.messageCMS/WithdrawMessage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MessageCMSServer is the server API for MessageCMS service. +type MessageCMSServer interface { + BoradcastMessage(context.Context, *BoradcastMessageReq) (*BoradcastMessageResp, error) + MassSendMessage(context.Context, *MassSendMessageReq) (*MassSendMessageResp, error) + GetChatLogs(context.Context, *GetChatLogsReq) (*GetChatLogsResp, error) + WithdrawMessage(context.Context, *WithdrawMessageReq) (*WithdrawMessageResp, error) +} + +// UnimplementedMessageCMSServer can be embedded to have forward compatible implementations. +type UnimplementedMessageCMSServer struct { +} + +func (*UnimplementedMessageCMSServer) BoradcastMessage(context.Context, *BoradcastMessageReq) (*BoradcastMessageResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method BoradcastMessage not implemented") +} +func (*UnimplementedMessageCMSServer) MassSendMessage(context.Context, *MassSendMessageReq) (*MassSendMessageResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method MassSendMessage not implemented") +} +func (*UnimplementedMessageCMSServer) GetChatLogs(context.Context, *GetChatLogsReq) (*GetChatLogsResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetChatLogs not implemented") +} +func (*UnimplementedMessageCMSServer) WithdrawMessage(context.Context, *WithdrawMessageReq) (*WithdrawMessageResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method WithdrawMessage not implemented") +} + +func RegisterMessageCMSServer(s *grpc.Server, srv MessageCMSServer) { + s.RegisterService(&_MessageCMS_serviceDesc, srv) +} + +func _MessageCMS_BoradcastMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BoradcastMessageReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageCMSServer).BoradcastMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/message_cms.messageCMS/BoradcastMessage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageCMSServer).BoradcastMessage(ctx, req.(*BoradcastMessageReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _MessageCMS_MassSendMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MassSendMessageReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageCMSServer).MassSendMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/message_cms.messageCMS/MassSendMessage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageCMSServer).MassSendMessage(ctx, req.(*MassSendMessageReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _MessageCMS_GetChatLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetChatLogsReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageCMSServer).GetChatLogs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/message_cms.messageCMS/GetChatLogs", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageCMSServer).GetChatLogs(ctx, req.(*GetChatLogsReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _MessageCMS_WithdrawMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(WithdrawMessageReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MessageCMSServer).WithdrawMessage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/message_cms.messageCMS/WithdrawMessage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MessageCMSServer).WithdrawMessage(ctx, req.(*WithdrawMessageReq)) + } + return interceptor(ctx, in, info, handler) +} + +var _MessageCMS_serviceDesc = grpc.ServiceDesc{ + ServiceName: "message_cms.messageCMS", + HandlerType: (*MessageCMSServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "BoradcastMessage", + Handler: _MessageCMS_BoradcastMessage_Handler, + }, + { + MethodName: "MassSendMessage", + Handler: _MessageCMS_MassSendMessage_Handler, + }, + { + MethodName: "GetChatLogs", + Handler: _MessageCMS_GetChatLogs_Handler, + }, + { + MethodName: "WithdrawMessage", + Handler: _MessageCMS_WithdrawMessage_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "message_cms/message_cms.proto", +} diff --git a/pkg/proto/message_cms/message_cms.proto b/pkg/proto/message_cms/message_cms.proto new file mode 100644 index 000000000..80b5e3102 --- /dev/null +++ b/pkg/proto/message_cms/message_cms.proto @@ -0,0 +1,70 @@ +syntax = "proto3"; +import "Open_IM/pkg/proto/sdk_ws/ws.proto"; +option go_package = "./message_cms;message_cms"; +package message_cms; + +message BoradcastMessageReq { + string Message = 1; + string OperationID = 2; +} + +message BoradcastMessageResp { + +} + +message MassSendMessageReq { + string Message = 1; + repeated string UserIds = 2; + string OperationID = 3; +} + +message MassSendMessageResp { + +} + +message GetChatLogsReq { + string Content = 1; + string UserId = 2; + string GroupId = 3; + string Date = 4; + int32 SessionType = 5; + int32 ContentType = 6; + server_api_params.RequestPagination Pagination = 7; + string OperationID = 8; + +} + +message ChatLogs { + int32 SessionType = 1; + int32 ContentType = 2; + string SenderNickName = 3; + string SenderId = 4; + string ReciverNickName = 5; + string ReciverId = 6; + string SearchContent = 7; + string WholeContent = 8; + string GroupId = 9; + string GroupName = 10; + string Date = 11; +} + +message GetChatLogsResp { + repeated ChatLogs ChatLogs = 1; + server_api_params.ResponsePagination Pagination = 2; +} + +message WithdrawMessageReq { + string ServerMsgId = 1; + string OperationID = 2; +} + +message WithdrawMessageResp { + +} + +service messageCMS { + rpc BoradcastMessage(BoradcastMessageReq) returns(BoradcastMessageResp); + rpc MassSendMessage(MassSendMessageReq) returns(MassSendMessageResp); + rpc GetChatLogs(GetChatLogsReq) returns(GetChatLogsResp); + rpc WithdrawMessage(WithdrawMessageReq) returns(WithdrawMessageResp); +} \ No newline at end of file diff --git a/pkg/proto/proto_dir.cfg b/pkg/proto/proto_dir.cfg index 1ad259e8a..4a9853fbd 100644 --- a/pkg/proto/proto_dir.cfg +++ b/pkg/proto/proto_dir.cfg @@ -1,5 +1,8 @@ all_proto=( + message_cms/message_cms.proto + admin_cms/admin_cms.proto + statistics/statistics.proto auth/auth.proto friend/friend.proto group/group.proto @@ -8,4 +11,5 @@ all_proto=( push/push.proto relay/relay.proto sdk_ws/ws.proto + ) diff --git a/pkg/proto/sdk_ws/ws.pb.go b/pkg/proto/sdk_ws/ws.pb.go index b8bfa10ce..11913a5c9 100644 --- a/pkg/proto/sdk_ws/ws.pb.go +++ b/pkg/proto/sdk_ws/ws.pb.go @@ -1,2616 +1,3958 @@ // Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.15.5 // source: sdk_ws/ws.proto package server_api_params -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) type GroupInfo struct { - GroupID string `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"` - GroupName string `protobuf:"bytes,2,opt,name=groupName" json:"groupName,omitempty"` - Notification string `protobuf:"bytes,3,opt,name=notification" json:"notification,omitempty"` - Introduction string `protobuf:"bytes,4,opt,name=introduction" json:"introduction,omitempty"` - FaceURL string `protobuf:"bytes,5,opt,name=faceURL" json:"faceURL,omitempty"` - OwnerUserID string `protobuf:"bytes,6,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - CreateTime uint32 `protobuf:"varint,7,opt,name=createTime" json:"createTime,omitempty"` - MemberCount uint32 `protobuf:"varint,8,opt,name=memberCount" json:"memberCount,omitempty"` - Ex string `protobuf:"bytes,9,opt,name=ex" json:"ex,omitempty"` - Status int32 `protobuf:"varint,10,opt,name=status" json:"status,omitempty"` - CreatorUserID string `protobuf:"bytes,11,opt,name=creatorUserID" json:"creatorUserID,omitempty"` - GroupType int32 `protobuf:"varint,12,opt,name=groupType" json:"groupType,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` + GroupName string `protobuf:"bytes,2,opt,name=groupName,proto3" json:"groupName,omitempty"` + Notification string `protobuf:"bytes,3,opt,name=notification,proto3" json:"notification,omitempty"` + Introduction string `protobuf:"bytes,4,opt,name=introduction,proto3" json:"introduction,omitempty"` + FaceURL string `protobuf:"bytes,5,opt,name=faceURL,proto3" json:"faceURL,omitempty"` + OwnerUserID string `protobuf:"bytes,6,opt,name=ownerUserID,proto3" json:"ownerUserID,omitempty"` + CreateTime uint32 `protobuf:"varint,7,opt,name=createTime,proto3" json:"createTime,omitempty"` + MemberCount uint32 `protobuf:"varint,8,opt,name=memberCount,proto3" json:"memberCount,omitempty"` + Ex string `protobuf:"bytes,9,opt,name=ex,proto3" json:"ex,omitempty"` + Status int32 `protobuf:"varint,10,opt,name=status,proto3" json:"status,omitempty"` + CreatorUserID string `protobuf:"bytes,11,opt,name=creatorUserID,proto3" json:"creatorUserID,omitempty"` + GroupType int32 `protobuf:"varint,12,opt,name=groupType,proto3" json:"groupType,omitempty"` } -func (m *GroupInfo) Reset() { *m = GroupInfo{} } -func (m *GroupInfo) String() string { return proto.CompactTextString(m) } -func (*GroupInfo) ProtoMessage() {} +func (x *GroupInfo) Reset() { + *x = GroupInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupInfo) ProtoMessage() {} + +func (x *GroupInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupInfo.ProtoReflect.Descriptor instead. func (*GroupInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{0} -} -func (m *GroupInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupInfo.Unmarshal(m, b) -} -func (m *GroupInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupInfo.Marshal(b, m, deterministic) -} -func (dst *GroupInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupInfo.Merge(dst, src) -} -func (m *GroupInfo) XXX_Size() int { - return xxx_messageInfo_GroupInfo.Size(m) -} -func (m *GroupInfo) XXX_DiscardUnknown() { - xxx_messageInfo_GroupInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{0} } -var xxx_messageInfo_GroupInfo proto.InternalMessageInfo - -func (m *GroupInfo) GetGroupID() string { - if m != nil { - return m.GroupID +func (x *GroupInfo) GetGroupID() string { + if x != nil { + return x.GroupID } return "" } -func (m *GroupInfo) GetGroupName() string { - if m != nil { - return m.GroupName +func (x *GroupInfo) GetGroupName() string { + if x != nil { + return x.GroupName } return "" } -func (m *GroupInfo) GetNotification() string { - if m != nil { - return m.Notification +func (x *GroupInfo) GetNotification() string { + if x != nil { + return x.Notification } return "" } -func (m *GroupInfo) GetIntroduction() string { - if m != nil { - return m.Introduction +func (x *GroupInfo) GetIntroduction() string { + if x != nil { + return x.Introduction } return "" } -func (m *GroupInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL +func (x *GroupInfo) GetFaceURL() string { + if x != nil { + return x.FaceURL } return "" } -func (m *GroupInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID +func (x *GroupInfo) GetOwnerUserID() string { + if x != nil { + return x.OwnerUserID } return "" } -func (m *GroupInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime +func (x *GroupInfo) GetCreateTime() uint32 { + if x != nil { + return x.CreateTime } return 0 } -func (m *GroupInfo) GetMemberCount() uint32 { - if m != nil { - return m.MemberCount +func (x *GroupInfo) GetMemberCount() uint32 { + if x != nil { + return x.MemberCount } return 0 } -func (m *GroupInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *GroupInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } -func (m *GroupInfo) GetStatus() int32 { - if m != nil { - return m.Status +func (x *GroupInfo) GetStatus() int32 { + if x != nil { + return x.Status } return 0 } -func (m *GroupInfo) GetCreatorUserID() string { - if m != nil { - return m.CreatorUserID +func (x *GroupInfo) GetCreatorUserID() string { + if x != nil { + return x.CreatorUserID } return "" } -func (m *GroupInfo) GetGroupType() int32 { - if m != nil { - return m.GroupType +func (x *GroupInfo) GetGroupType() int32 { + if x != nil { + return x.GroupType } return 0 } type GroupMemberFullInfo struct { - GroupID string `protobuf:"bytes,1,opt,name=groupID" json:"groupID,omitempty"` - UserID string `protobuf:"bytes,2,opt,name=userID" json:"userID,omitempty"` - RoleLevel int32 `protobuf:"varint,3,opt,name=roleLevel" json:"roleLevel,omitempty"` - JoinTime int64 `protobuf:"varint,4,opt,name=joinTime" json:"joinTime,omitempty"` - Nickname string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,6,opt,name=faceURL" json:"faceURL,omitempty"` - AppMangerLevel int32 `protobuf:"varint,7,opt,name=appMangerLevel" json:"appMangerLevel,omitempty"` - JoinSource int32 `protobuf:"varint,8,opt,name=joinSource" json:"joinSource,omitempty"` - OperatorUserID string `protobuf:"bytes,9,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,10,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupID string `protobuf:"bytes,1,opt,name=groupID,proto3" json:"groupID,omitempty"` + UserID string `protobuf:"bytes,2,opt,name=userID,proto3" json:"userID,omitempty"` + RoleLevel int32 `protobuf:"varint,3,opt,name=roleLevel,proto3" json:"roleLevel,omitempty"` + JoinTime int64 `protobuf:"varint,4,opt,name=joinTime,proto3" json:"joinTime,omitempty"` + Nickname string `protobuf:"bytes,5,opt,name=nickname,proto3" json:"nickname,omitempty"` + FaceURL string `protobuf:"bytes,6,opt,name=faceURL,proto3" json:"faceURL,omitempty"` + AppMangerLevel int32 `protobuf:"varint,7,opt,name=appMangerLevel,proto3" json:"appMangerLevel,omitempty"` //if >0 + JoinSource int32 `protobuf:"varint,8,opt,name=joinSource,proto3" json:"joinSource,omitempty"` + OperatorUserID string `protobuf:"bytes,9,opt,name=operatorUserID,proto3" json:"operatorUserID,omitempty"` + Ex string `protobuf:"bytes,10,opt,name=ex,proto3" json:"ex,omitempty"` } -func (m *GroupMemberFullInfo) Reset() { *m = GroupMemberFullInfo{} } -func (m *GroupMemberFullInfo) String() string { return proto.CompactTextString(m) } -func (*GroupMemberFullInfo) ProtoMessage() {} +func (x *GroupMemberFullInfo) Reset() { + *x = GroupMemberFullInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupMemberFullInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupMemberFullInfo) ProtoMessage() {} + +func (x *GroupMemberFullInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupMemberFullInfo.ProtoReflect.Descriptor instead. func (*GroupMemberFullInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{1} -} -func (m *GroupMemberFullInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupMemberFullInfo.Unmarshal(m, b) -} -func (m *GroupMemberFullInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupMemberFullInfo.Marshal(b, m, deterministic) -} -func (dst *GroupMemberFullInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupMemberFullInfo.Merge(dst, src) -} -func (m *GroupMemberFullInfo) XXX_Size() int { - return xxx_messageInfo_GroupMemberFullInfo.Size(m) -} -func (m *GroupMemberFullInfo) XXX_DiscardUnknown() { - xxx_messageInfo_GroupMemberFullInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{1} } -var xxx_messageInfo_GroupMemberFullInfo proto.InternalMessageInfo - -func (m *GroupMemberFullInfo) GetGroupID() string { - if m != nil { - return m.GroupID +func (x *GroupMemberFullInfo) GetGroupID() string { + if x != nil { + return x.GroupID } return "" } -func (m *GroupMemberFullInfo) GetUserID() string { - if m != nil { - return m.UserID +func (x *GroupMemberFullInfo) GetUserID() string { + if x != nil { + return x.UserID } return "" } -func (m *GroupMemberFullInfo) GetRoleLevel() int32 { - if m != nil { - return m.RoleLevel +func (x *GroupMemberFullInfo) GetRoleLevel() int32 { + if x != nil { + return x.RoleLevel } return 0 } -func (m *GroupMemberFullInfo) GetJoinTime() int64 { - if m != nil { - return m.JoinTime +func (x *GroupMemberFullInfo) GetJoinTime() int64 { + if x != nil { + return x.JoinTime } return 0 } -func (m *GroupMemberFullInfo) GetNickname() string { - if m != nil { - return m.Nickname +func (x *GroupMemberFullInfo) GetNickname() string { + if x != nil { + return x.Nickname } return "" } -func (m *GroupMemberFullInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL +func (x *GroupMemberFullInfo) GetFaceURL() string { + if x != nil { + return x.FaceURL } return "" } -func (m *GroupMemberFullInfo) GetAppMangerLevel() int32 { - if m != nil { - return m.AppMangerLevel +func (x *GroupMemberFullInfo) GetAppMangerLevel() int32 { + if x != nil { + return x.AppMangerLevel } return 0 } -func (m *GroupMemberFullInfo) GetJoinSource() int32 { - if m != nil { - return m.JoinSource +func (x *GroupMemberFullInfo) GetJoinSource() int32 { + if x != nil { + return x.JoinSource } return 0 } -func (m *GroupMemberFullInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID +func (x *GroupMemberFullInfo) GetOperatorUserID() string { + if x != nil { + return x.OperatorUserID } return "" } -func (m *GroupMemberFullInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *GroupMemberFullInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } type PublicUserInfo struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - Nickname string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,3,opt,name=faceURL" json:"faceURL,omitempty"` - Gender int32 `protobuf:"varint,4,opt,name=gender" json:"gender,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` + Nickname string `protobuf:"bytes,2,opt,name=nickname,proto3" json:"nickname,omitempty"` + FaceURL string `protobuf:"bytes,3,opt,name=faceURL,proto3" json:"faceURL,omitempty"` + Gender int32 `protobuf:"varint,4,opt,name=gender,proto3" json:"gender,omitempty"` } -func (m *PublicUserInfo) Reset() { *m = PublicUserInfo{} } -func (m *PublicUserInfo) String() string { return proto.CompactTextString(m) } -func (*PublicUserInfo) ProtoMessage() {} +func (x *PublicUserInfo) Reset() { + *x = PublicUserInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PublicUserInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PublicUserInfo) ProtoMessage() {} + +func (x *PublicUserInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PublicUserInfo.ProtoReflect.Descriptor instead. func (*PublicUserInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{2} -} -func (m *PublicUserInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PublicUserInfo.Unmarshal(m, b) -} -func (m *PublicUserInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PublicUserInfo.Marshal(b, m, deterministic) -} -func (dst *PublicUserInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_PublicUserInfo.Merge(dst, src) -} -func (m *PublicUserInfo) XXX_Size() int { - return xxx_messageInfo_PublicUserInfo.Size(m) -} -func (m *PublicUserInfo) XXX_DiscardUnknown() { - xxx_messageInfo_PublicUserInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{2} } -var xxx_messageInfo_PublicUserInfo proto.InternalMessageInfo - -func (m *PublicUserInfo) GetUserID() string { - if m != nil { - return m.UserID +func (x *PublicUserInfo) GetUserID() string { + if x != nil { + return x.UserID } return "" } -func (m *PublicUserInfo) GetNickname() string { - if m != nil { - return m.Nickname +func (x *PublicUserInfo) GetNickname() string { + if x != nil { + return x.Nickname } return "" } -func (m *PublicUserInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL +func (x *PublicUserInfo) GetFaceURL() string { + if x != nil { + return x.FaceURL } return "" } -func (m *PublicUserInfo) GetGender() int32 { - if m != nil { - return m.Gender +func (x *PublicUserInfo) GetGender() int32 { + if x != nil { + return x.Gender } return 0 } type UserInfo struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - Nickname string `protobuf:"bytes,2,opt,name=nickname" json:"nickname,omitempty"` - FaceURL string `protobuf:"bytes,3,opt,name=faceURL" json:"faceURL,omitempty"` - Gender int32 `protobuf:"varint,4,opt,name=gender" json:"gender,omitempty"` - PhoneNumber string `protobuf:"bytes,5,opt,name=phoneNumber" json:"phoneNumber,omitempty"` - Birth uint32 `protobuf:"varint,6,opt,name=birth" json:"birth,omitempty"` - Email string `protobuf:"bytes,7,opt,name=email" json:"email,omitempty"` - Ex string `protobuf:"bytes,8,opt,name=ex" json:"ex,omitempty"` - CreateTime uint32 `protobuf:"varint,9,opt,name=createTime" json:"createTime,omitempty"` - AppMangerLevel int32 `protobuf:"varint,10,opt,name=appMangerLevel" json:"appMangerLevel,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` + Nickname string `protobuf:"bytes,2,opt,name=nickname,proto3" json:"nickname,omitempty"` + FaceURL string `protobuf:"bytes,3,opt,name=faceURL,proto3" json:"faceURL,omitempty"` + Gender int32 `protobuf:"varint,4,opt,name=gender,proto3" json:"gender,omitempty"` + PhoneNumber string `protobuf:"bytes,5,opt,name=phoneNumber,proto3" json:"phoneNumber,omitempty"` + Birth uint32 `protobuf:"varint,6,opt,name=birth,proto3" json:"birth,omitempty"` + Email string `protobuf:"bytes,7,opt,name=email,proto3" json:"email,omitempty"` + Ex string `protobuf:"bytes,8,opt,name=ex,proto3" json:"ex,omitempty"` + CreateTime uint32 `protobuf:"varint,9,opt,name=createTime,proto3" json:"createTime,omitempty"` + AppMangerLevel int32 `protobuf:"varint,10,opt,name=appMangerLevel,proto3" json:"appMangerLevel,omitempty"` } -func (m *UserInfo) Reset() { *m = UserInfo{} } -func (m *UserInfo) String() string { return proto.CompactTextString(m) } -func (*UserInfo) ProtoMessage() {} +func (x *UserInfo) Reset() { + *x = UserInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserInfo) ProtoMessage() {} + +func (x *UserInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserInfo.ProtoReflect.Descriptor instead. func (*UserInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{3} -} -func (m *UserInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserInfo.Unmarshal(m, b) -} -func (m *UserInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserInfo.Marshal(b, m, deterministic) -} -func (dst *UserInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserInfo.Merge(dst, src) -} -func (m *UserInfo) XXX_Size() int { - return xxx_messageInfo_UserInfo.Size(m) -} -func (m *UserInfo) XXX_DiscardUnknown() { - xxx_messageInfo_UserInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{3} } -var xxx_messageInfo_UserInfo proto.InternalMessageInfo - -func (m *UserInfo) GetUserID() string { - if m != nil { - return m.UserID +func (x *UserInfo) GetUserID() string { + if x != nil { + return x.UserID } return "" } -func (m *UserInfo) GetNickname() string { - if m != nil { - return m.Nickname +func (x *UserInfo) GetNickname() string { + if x != nil { + return x.Nickname } return "" } -func (m *UserInfo) GetFaceURL() string { - if m != nil { - return m.FaceURL +func (x *UserInfo) GetFaceURL() string { + if x != nil { + return x.FaceURL } return "" } -func (m *UserInfo) GetGender() int32 { - if m != nil { - return m.Gender +func (x *UserInfo) GetGender() int32 { + if x != nil { + return x.Gender } return 0 } -func (m *UserInfo) GetPhoneNumber() string { - if m != nil { - return m.PhoneNumber +func (x *UserInfo) GetPhoneNumber() string { + if x != nil { + return x.PhoneNumber } return "" } -func (m *UserInfo) GetBirth() uint32 { - if m != nil { - return m.Birth +func (x *UserInfo) GetBirth() uint32 { + if x != nil { + return x.Birth } return 0 } -func (m *UserInfo) GetEmail() string { - if m != nil { - return m.Email +func (x *UserInfo) GetEmail() string { + if x != nil { + return x.Email } return "" } -func (m *UserInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *UserInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } -func (m *UserInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime +func (x *UserInfo) GetCreateTime() uint32 { + if x != nil { + return x.CreateTime } return 0 } -func (m *UserInfo) GetAppMangerLevel() int32 { - if m != nil { - return m.AppMangerLevel +func (x *UserInfo) GetAppMangerLevel() int32 { + if x != nil { + return x.AppMangerLevel } return 0 } type FriendInfo struct { - OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - Remark string `protobuf:"bytes,2,opt,name=remark" json:"remark,omitempty"` - CreateTime uint32 `protobuf:"varint,3,opt,name=createTime" json:"createTime,omitempty"` - FriendUser *UserInfo `protobuf:"bytes,4,opt,name=friendUser" json:"friendUser,omitempty"` - AddSource int32 `protobuf:"varint,5,opt,name=addSource" json:"addSource,omitempty"` - OperatorUserID string `protobuf:"bytes,6,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,7,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID,proto3" json:"ownerUserID,omitempty"` + Remark string `protobuf:"bytes,2,opt,name=remark,proto3" json:"remark,omitempty"` + CreateTime uint32 `protobuf:"varint,3,opt,name=createTime,proto3" json:"createTime,omitempty"` + FriendUser *UserInfo `protobuf:"bytes,4,opt,name=friendUser,proto3" json:"friendUser,omitempty"` + AddSource int32 `protobuf:"varint,5,opt,name=addSource,proto3" json:"addSource,omitempty"` + OperatorUserID string `protobuf:"bytes,6,opt,name=operatorUserID,proto3" json:"operatorUserID,omitempty"` + Ex string `protobuf:"bytes,7,opt,name=ex,proto3" json:"ex,omitempty"` } -func (m *FriendInfo) Reset() { *m = FriendInfo{} } -func (m *FriendInfo) String() string { return proto.CompactTextString(m) } -func (*FriendInfo) ProtoMessage() {} +func (x *FriendInfo) Reset() { + *x = FriendInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendInfo) ProtoMessage() {} + +func (x *FriendInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendInfo.ProtoReflect.Descriptor instead. func (*FriendInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{4} -} -func (m *FriendInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendInfo.Unmarshal(m, b) -} -func (m *FriendInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendInfo.Marshal(b, m, deterministic) -} -func (dst *FriendInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendInfo.Merge(dst, src) -} -func (m *FriendInfo) XXX_Size() int { - return xxx_messageInfo_FriendInfo.Size(m) -} -func (m *FriendInfo) XXX_DiscardUnknown() { - xxx_messageInfo_FriendInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{4} } -var xxx_messageInfo_FriendInfo proto.InternalMessageInfo - -func (m *FriendInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID +func (x *FriendInfo) GetOwnerUserID() string { + if x != nil { + return x.OwnerUserID } return "" } -func (m *FriendInfo) GetRemark() string { - if m != nil { - return m.Remark +func (x *FriendInfo) GetRemark() string { + if x != nil { + return x.Remark } return "" } -func (m *FriendInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime +func (x *FriendInfo) GetCreateTime() uint32 { + if x != nil { + return x.CreateTime } return 0 } -func (m *FriendInfo) GetFriendUser() *UserInfo { - if m != nil { - return m.FriendUser +func (x *FriendInfo) GetFriendUser() *UserInfo { + if x != nil { + return x.FriendUser } return nil } -func (m *FriendInfo) GetAddSource() int32 { - if m != nil { - return m.AddSource +func (x *FriendInfo) GetAddSource() int32 { + if x != nil { + return x.AddSource } return 0 } -func (m *FriendInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID +func (x *FriendInfo) GetOperatorUserID() string { + if x != nil { + return x.OperatorUserID } return "" } -func (m *FriendInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *FriendInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } type BlackInfo struct { - OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID" json:"ownerUserID,omitempty"` - CreateTime uint32 `protobuf:"varint,2,opt,name=createTime" json:"createTime,omitempty"` - BlackUserInfo *PublicUserInfo `protobuf:"bytes,3,opt,name=blackUserInfo" json:"blackUserInfo,omitempty"` - AddSource int32 `protobuf:"varint,4,opt,name=addSource" json:"addSource,omitempty"` - OperatorUserID string `protobuf:"bytes,5,opt,name=operatorUserID" json:"operatorUserID,omitempty"` - Ex string `protobuf:"bytes,6,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OwnerUserID string `protobuf:"bytes,1,opt,name=ownerUserID,proto3" json:"ownerUserID,omitempty"` + CreateTime uint32 `protobuf:"varint,2,opt,name=createTime,proto3" json:"createTime,omitempty"` + BlackUserInfo *PublicUserInfo `protobuf:"bytes,3,opt,name=blackUserInfo,proto3" json:"blackUserInfo,omitempty"` + AddSource int32 `protobuf:"varint,4,opt,name=addSource,proto3" json:"addSource,omitempty"` + OperatorUserID string `protobuf:"bytes,5,opt,name=operatorUserID,proto3" json:"operatorUserID,omitempty"` + Ex string `protobuf:"bytes,6,opt,name=ex,proto3" json:"ex,omitempty"` } -func (m *BlackInfo) Reset() { *m = BlackInfo{} } -func (m *BlackInfo) String() string { return proto.CompactTextString(m) } -func (*BlackInfo) ProtoMessage() {} +func (x *BlackInfo) Reset() { + *x = BlackInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlackInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlackInfo) ProtoMessage() {} + +func (x *BlackInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlackInfo.ProtoReflect.Descriptor instead. func (*BlackInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{5} -} -func (m *BlackInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackInfo.Unmarshal(m, b) -} -func (m *BlackInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackInfo.Marshal(b, m, deterministic) -} -func (dst *BlackInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackInfo.Merge(dst, src) -} -func (m *BlackInfo) XXX_Size() int { - return xxx_messageInfo_BlackInfo.Size(m) -} -func (m *BlackInfo) XXX_DiscardUnknown() { - xxx_messageInfo_BlackInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{5} } -var xxx_messageInfo_BlackInfo proto.InternalMessageInfo - -func (m *BlackInfo) GetOwnerUserID() string { - if m != nil { - return m.OwnerUserID +func (x *BlackInfo) GetOwnerUserID() string { + if x != nil { + return x.OwnerUserID } return "" } -func (m *BlackInfo) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime +func (x *BlackInfo) GetCreateTime() uint32 { + if x != nil { + return x.CreateTime } return 0 } -func (m *BlackInfo) GetBlackUserInfo() *PublicUserInfo { - if m != nil { - return m.BlackUserInfo +func (x *BlackInfo) GetBlackUserInfo() *PublicUserInfo { + if x != nil { + return x.BlackUserInfo } return nil } -func (m *BlackInfo) GetAddSource() int32 { - if m != nil { - return m.AddSource +func (x *BlackInfo) GetAddSource() int32 { + if x != nil { + return x.AddSource } return 0 } -func (m *BlackInfo) GetOperatorUserID() string { - if m != nil { - return m.OperatorUserID +func (x *BlackInfo) GetOperatorUserID() string { + if x != nil { + return x.OperatorUserID } return "" } -func (m *BlackInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *BlackInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } type GroupRequest struct { - UserInfo *PublicUserInfo `protobuf:"bytes,1,opt,name=userInfo" json:"userInfo,omitempty"` - GroupInfo *GroupInfo `protobuf:"bytes,2,opt,name=groupInfo" json:"groupInfo,omitempty"` - HandleResult int32 `protobuf:"varint,3,opt,name=handleResult" json:"handleResult,omitempty"` - ReqMsg string `protobuf:"bytes,4,opt,name=reqMsg" json:"reqMsg,omitempty"` - HandleMsg string `protobuf:"bytes,5,opt,name=handleMsg" json:"handleMsg,omitempty"` - ReqTime uint32 `protobuf:"varint,6,opt,name=reqTime" json:"reqTime,omitempty"` - HandleUserID string `protobuf:"bytes,7,opt,name=handleUserID" json:"handleUserID,omitempty"` - HandleTime uint32 `protobuf:"varint,8,opt,name=handleTime" json:"handleTime,omitempty"` - Ex string `protobuf:"bytes,9,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserInfo *PublicUserInfo `protobuf:"bytes,1,opt,name=userInfo,proto3" json:"userInfo,omitempty"` + GroupInfo *GroupInfo `protobuf:"bytes,2,opt,name=groupInfo,proto3" json:"groupInfo,omitempty"` + HandleResult int32 `protobuf:"varint,3,opt,name=handleResult,proto3" json:"handleResult,omitempty"` + ReqMsg string `protobuf:"bytes,4,opt,name=reqMsg,proto3" json:"reqMsg,omitempty"` + HandleMsg string `protobuf:"bytes,5,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` + ReqTime uint32 `protobuf:"varint,6,opt,name=reqTime,proto3" json:"reqTime,omitempty"` + HandleUserID string `protobuf:"bytes,7,opt,name=handleUserID,proto3" json:"handleUserID,omitempty"` + HandleTime uint32 `protobuf:"varint,8,opt,name=handleTime,proto3" json:"handleTime,omitempty"` + Ex string `protobuf:"bytes,9,opt,name=ex,proto3" json:"ex,omitempty"` } -func (m *GroupRequest) Reset() { *m = GroupRequest{} } -func (m *GroupRequest) String() string { return proto.CompactTextString(m) } -func (*GroupRequest) ProtoMessage() {} +func (x *GroupRequest) Reset() { + *x = GroupRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupRequest) ProtoMessage() {} + +func (x *GroupRequest) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupRequest.ProtoReflect.Descriptor instead. func (*GroupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{6} -} -func (m *GroupRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupRequest.Unmarshal(m, b) -} -func (m *GroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupRequest.Marshal(b, m, deterministic) -} -func (dst *GroupRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupRequest.Merge(dst, src) -} -func (m *GroupRequest) XXX_Size() int { - return xxx_messageInfo_GroupRequest.Size(m) -} -func (m *GroupRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GroupRequest.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{6} } -var xxx_messageInfo_GroupRequest proto.InternalMessageInfo - -func (m *GroupRequest) GetUserInfo() *PublicUserInfo { - if m != nil { - return m.UserInfo +func (x *GroupRequest) GetUserInfo() *PublicUserInfo { + if x != nil { + return x.UserInfo } return nil } -func (m *GroupRequest) GetGroupInfo() *GroupInfo { - if m != nil { - return m.GroupInfo +func (x *GroupRequest) GetGroupInfo() *GroupInfo { + if x != nil { + return x.GroupInfo } return nil } -func (m *GroupRequest) GetHandleResult() int32 { - if m != nil { - return m.HandleResult +func (x *GroupRequest) GetHandleResult() int32 { + if x != nil { + return x.HandleResult } return 0 } -func (m *GroupRequest) GetReqMsg() string { - if m != nil { - return m.ReqMsg +func (x *GroupRequest) GetReqMsg() string { + if x != nil { + return x.ReqMsg } return "" } -func (m *GroupRequest) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *GroupRequest) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } -func (m *GroupRequest) GetReqTime() uint32 { - if m != nil { - return m.ReqTime +func (x *GroupRequest) GetReqTime() uint32 { + if x != nil { + return x.ReqTime } return 0 } -func (m *GroupRequest) GetHandleUserID() string { - if m != nil { - return m.HandleUserID +func (x *GroupRequest) GetHandleUserID() string { + if x != nil { + return x.HandleUserID } return "" } -func (m *GroupRequest) GetHandleTime() uint32 { - if m != nil { - return m.HandleTime +func (x *GroupRequest) GetHandleTime() uint32 { + if x != nil { + return x.HandleTime } return 0 } -func (m *GroupRequest) GetEx() string { - if m != nil { - return m.Ex +func (x *GroupRequest) GetEx() string { + if x != nil { + return x.Ex } return "" } type FriendRequest struct { - FromUserID string `protobuf:"bytes,1,opt,name=fromUserID" json:"fromUserID,omitempty"` - FromNickname string `protobuf:"bytes,2,opt,name=fromNickname" json:"fromNickname,omitempty"` - FromFaceURL string `protobuf:"bytes,3,opt,name=fromFaceURL" json:"fromFaceURL,omitempty"` - FromGender int32 `protobuf:"varint,4,opt,name=fromGender" json:"fromGender,omitempty"` - ToUserID string `protobuf:"bytes,5,opt,name=toUserID" json:"toUserID,omitempty"` - ToNickname string `protobuf:"bytes,6,opt,name=toNickname" json:"toNickname,omitempty"` - ToFaceURL string `protobuf:"bytes,7,opt,name=toFaceURL" json:"toFaceURL,omitempty"` - ToGender int32 `protobuf:"varint,8,opt,name=toGender" json:"toGender,omitempty"` - HandleResult int32 `protobuf:"varint,9,opt,name=handleResult" json:"handleResult,omitempty"` - ReqMsg string `protobuf:"bytes,10,opt,name=reqMsg" json:"reqMsg,omitempty"` - CreateTime uint32 `protobuf:"varint,11,opt,name=createTime" json:"createTime,omitempty"` - HandlerUserID string `protobuf:"bytes,12,opt,name=handlerUserID" json:"handlerUserID,omitempty"` - HandleMsg string `protobuf:"bytes,13,opt,name=handleMsg" json:"handleMsg,omitempty"` - HandleTime uint32 `protobuf:"varint,14,opt,name=handleTime" json:"handleTime,omitempty"` - Ex string `protobuf:"bytes,15,opt,name=ex" json:"ex,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromUserID string `protobuf:"bytes,1,opt,name=fromUserID,proto3" json:"fromUserID,omitempty"` + FromNickname string `protobuf:"bytes,2,opt,name=fromNickname,proto3" json:"fromNickname,omitempty"` + FromFaceURL string `protobuf:"bytes,3,opt,name=fromFaceURL,proto3" json:"fromFaceURL,omitempty"` + FromGender int32 `protobuf:"varint,4,opt,name=fromGender,proto3" json:"fromGender,omitempty"` + ToUserID string `protobuf:"bytes,5,opt,name=toUserID,proto3" json:"toUserID,omitempty"` + ToNickname string `protobuf:"bytes,6,opt,name=toNickname,proto3" json:"toNickname,omitempty"` + ToFaceURL string `protobuf:"bytes,7,opt,name=toFaceURL,proto3" json:"toFaceURL,omitempty"` + ToGender int32 `protobuf:"varint,8,opt,name=toGender,proto3" json:"toGender,omitempty"` + HandleResult int32 `protobuf:"varint,9,opt,name=handleResult,proto3" json:"handleResult,omitempty"` + ReqMsg string `protobuf:"bytes,10,opt,name=reqMsg,proto3" json:"reqMsg,omitempty"` + CreateTime uint32 `protobuf:"varint,11,opt,name=createTime,proto3" json:"createTime,omitempty"` + HandlerUserID string `protobuf:"bytes,12,opt,name=handlerUserID,proto3" json:"handlerUserID,omitempty"` + HandleMsg string `protobuf:"bytes,13,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` + HandleTime uint32 `protobuf:"varint,14,opt,name=handleTime,proto3" json:"handleTime,omitempty"` + Ex string `protobuf:"bytes,15,opt,name=ex,proto3" json:"ex,omitempty"` } -func (m *FriendRequest) Reset() { *m = FriendRequest{} } -func (m *FriendRequest) String() string { return proto.CompactTextString(m) } -func (*FriendRequest) ProtoMessage() {} +func (x *FriendRequest) Reset() { + *x = FriendRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendRequest) ProtoMessage() {} + +func (x *FriendRequest) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendRequest.ProtoReflect.Descriptor instead. func (*FriendRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{7} -} -func (m *FriendRequest) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendRequest.Unmarshal(m, b) -} -func (m *FriendRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendRequest.Marshal(b, m, deterministic) -} -func (dst *FriendRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendRequest.Merge(dst, src) -} -func (m *FriendRequest) XXX_Size() int { - return xxx_messageInfo_FriendRequest.Size(m) -} -func (m *FriendRequest) XXX_DiscardUnknown() { - xxx_messageInfo_FriendRequest.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{7} } -var xxx_messageInfo_FriendRequest proto.InternalMessageInfo - -func (m *FriendRequest) GetFromUserID() string { - if m != nil { - return m.FromUserID +func (x *FriendRequest) GetFromUserID() string { + if x != nil { + return x.FromUserID } return "" } -func (m *FriendRequest) GetFromNickname() string { - if m != nil { - return m.FromNickname +func (x *FriendRequest) GetFromNickname() string { + if x != nil { + return x.FromNickname } return "" } -func (m *FriendRequest) GetFromFaceURL() string { - if m != nil { - return m.FromFaceURL +func (x *FriendRequest) GetFromFaceURL() string { + if x != nil { + return x.FromFaceURL } return "" } -func (m *FriendRequest) GetFromGender() int32 { - if m != nil { - return m.FromGender +func (x *FriendRequest) GetFromGender() int32 { + if x != nil { + return x.FromGender } return 0 } -func (m *FriendRequest) GetToUserID() string { - if m != nil { - return m.ToUserID +func (x *FriendRequest) GetToUserID() string { + if x != nil { + return x.ToUserID } return "" } -func (m *FriendRequest) GetToNickname() string { - if m != nil { - return m.ToNickname +func (x *FriendRequest) GetToNickname() string { + if x != nil { + return x.ToNickname } return "" } -func (m *FriendRequest) GetToFaceURL() string { - if m != nil { - return m.ToFaceURL +func (x *FriendRequest) GetToFaceURL() string { + if x != nil { + return x.ToFaceURL } return "" } -func (m *FriendRequest) GetToGender() int32 { - if m != nil { - return m.ToGender +func (x *FriendRequest) GetToGender() int32 { + if x != nil { + return x.ToGender } return 0 } -func (m *FriendRequest) GetHandleResult() int32 { - if m != nil { - return m.HandleResult +func (x *FriendRequest) GetHandleResult() int32 { + if x != nil { + return x.HandleResult } return 0 } -func (m *FriendRequest) GetReqMsg() string { - if m != nil { - return m.ReqMsg +func (x *FriendRequest) GetReqMsg() string { + if x != nil { + return x.ReqMsg } return "" } -func (m *FriendRequest) GetCreateTime() uint32 { - if m != nil { - return m.CreateTime +func (x *FriendRequest) GetCreateTime() uint32 { + if x != nil { + return x.CreateTime } return 0 } -func (m *FriendRequest) GetHandlerUserID() string { - if m != nil { - return m.HandlerUserID +func (x *FriendRequest) GetHandlerUserID() string { + if x != nil { + return x.HandlerUserID } return "" } -func (m *FriendRequest) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *FriendRequest) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } -func (m *FriendRequest) GetHandleTime() uint32 { - if m != nil { - return m.HandleTime +func (x *FriendRequest) GetHandleTime() uint32 { + if x != nil { + return x.HandleTime } return 0 } -func (m *FriendRequest) GetEx() string { - if m != nil { - return m.Ex +func (x *FriendRequest) GetEx() string { + if x != nil { + return x.Ex } return "" } type PullMessageBySeqListResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - List []*MsgData `protobuf:"bytes,3,rep,name=list" json:"list,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode int32 `protobuf:"varint,1,opt,name=errCode,proto3" json:"errCode,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=errMsg,proto3" json:"errMsg,omitempty"` + List []*MsgData `protobuf:"bytes,3,rep,name=list,proto3" json:"list,omitempty"` } -func (m *PullMessageBySeqListResp) Reset() { *m = PullMessageBySeqListResp{} } -func (m *PullMessageBySeqListResp) String() string { return proto.CompactTextString(m) } -func (*PullMessageBySeqListResp) ProtoMessage() {} +func (x *PullMessageBySeqListResp) Reset() { + *x = PullMessageBySeqListResp{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PullMessageBySeqListResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PullMessageBySeqListResp) ProtoMessage() {} + +func (x *PullMessageBySeqListResp) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PullMessageBySeqListResp.ProtoReflect.Descriptor instead. func (*PullMessageBySeqListResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{8} -} -func (m *PullMessageBySeqListResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PullMessageBySeqListResp.Unmarshal(m, b) -} -func (m *PullMessageBySeqListResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PullMessageBySeqListResp.Marshal(b, m, deterministic) -} -func (dst *PullMessageBySeqListResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_PullMessageBySeqListResp.Merge(dst, src) -} -func (m *PullMessageBySeqListResp) XXX_Size() int { - return xxx_messageInfo_PullMessageBySeqListResp.Size(m) -} -func (m *PullMessageBySeqListResp) XXX_DiscardUnknown() { - xxx_messageInfo_PullMessageBySeqListResp.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{8} } -var xxx_messageInfo_PullMessageBySeqListResp proto.InternalMessageInfo - -func (m *PullMessageBySeqListResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode +func (x *PullMessageBySeqListResp) GetErrCode() int32 { + if x != nil { + return x.ErrCode } return 0 } -func (m *PullMessageBySeqListResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg +func (x *PullMessageBySeqListResp) GetErrMsg() string { + if x != nil { + return x.ErrMsg } return "" } -func (m *PullMessageBySeqListResp) GetList() []*MsgData { - if m != nil { - return m.List +func (x *PullMessageBySeqListResp) GetList() []*MsgData { + if x != nil { + return x.List } return nil } type PullMessageBySeqListReq struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - SeqList []uint32 `protobuf:"varint,3,rep,packed,name=seqList" json:"seqList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=operationID,proto3" json:"operationID,omitempty"` + SeqList []uint32 `protobuf:"varint,3,rep,packed,name=seqList,proto3" json:"seqList,omitempty"` } -func (m *PullMessageBySeqListReq) Reset() { *m = PullMessageBySeqListReq{} } -func (m *PullMessageBySeqListReq) String() string { return proto.CompactTextString(m) } -func (*PullMessageBySeqListReq) ProtoMessage() {} +func (x *PullMessageBySeqListReq) Reset() { + *x = PullMessageBySeqListReq{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PullMessageBySeqListReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PullMessageBySeqListReq) ProtoMessage() {} + +func (x *PullMessageBySeqListReq) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PullMessageBySeqListReq.ProtoReflect.Descriptor instead. func (*PullMessageBySeqListReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{9} -} -func (m *PullMessageBySeqListReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_PullMessageBySeqListReq.Unmarshal(m, b) -} -func (m *PullMessageBySeqListReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_PullMessageBySeqListReq.Marshal(b, m, deterministic) -} -func (dst *PullMessageBySeqListReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_PullMessageBySeqListReq.Merge(dst, src) -} -func (m *PullMessageBySeqListReq) XXX_Size() int { - return xxx_messageInfo_PullMessageBySeqListReq.Size(m) -} -func (m *PullMessageBySeqListReq) XXX_DiscardUnknown() { - xxx_messageInfo_PullMessageBySeqListReq.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{9} } -var xxx_messageInfo_PullMessageBySeqListReq proto.InternalMessageInfo - -func (m *PullMessageBySeqListReq) GetUserID() string { - if m != nil { - return m.UserID +func (x *PullMessageBySeqListReq) GetUserID() string { + if x != nil { + return x.UserID } return "" } -func (m *PullMessageBySeqListReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *PullMessageBySeqListReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } -func (m *PullMessageBySeqListReq) GetSeqList() []uint32 { - if m != nil { - return m.SeqList +func (x *PullMessageBySeqListReq) GetSeqList() []uint32 { + if x != nil { + return x.SeqList } return nil } type GetMaxAndMinSeqReq struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (m *GetMaxAndMinSeqReq) Reset() { *m = GetMaxAndMinSeqReq{} } -func (m *GetMaxAndMinSeqReq) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqReq) ProtoMessage() {} +func (x *GetMaxAndMinSeqReq) Reset() { + *x = GetMaxAndMinSeqReq{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetMaxAndMinSeqReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMaxAndMinSeqReq) ProtoMessage() {} + +func (x *GetMaxAndMinSeqReq) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMaxAndMinSeqReq.ProtoReflect.Descriptor instead. func (*GetMaxAndMinSeqReq) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{10} + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{10} } -func (m *GetMaxAndMinSeqReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqReq.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqReq.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqReq.Merge(dst, src) -} -func (m *GetMaxAndMinSeqReq) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqReq.Size(m) -} -func (m *GetMaxAndMinSeqReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqReq.DiscardUnknown(m) -} - -var xxx_messageInfo_GetMaxAndMinSeqReq proto.InternalMessageInfo type GetMaxAndMinSeqResp struct { - MaxSeq uint32 `protobuf:"varint,1,opt,name=maxSeq" json:"maxSeq,omitempty"` - MinSeq uint32 `protobuf:"varint,2,opt,name=minSeq" json:"minSeq,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + MaxSeq uint32 `protobuf:"varint,1,opt,name=maxSeq,proto3" json:"maxSeq,omitempty"` + MinSeq uint32 `protobuf:"varint,2,opt,name=minSeq,proto3" json:"minSeq,omitempty"` } -func (m *GetMaxAndMinSeqResp) Reset() { *m = GetMaxAndMinSeqResp{} } -func (m *GetMaxAndMinSeqResp) String() string { return proto.CompactTextString(m) } -func (*GetMaxAndMinSeqResp) ProtoMessage() {} +func (x *GetMaxAndMinSeqResp) Reset() { + *x = GetMaxAndMinSeqResp{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetMaxAndMinSeqResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMaxAndMinSeqResp) ProtoMessage() {} + +func (x *GetMaxAndMinSeqResp) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMaxAndMinSeqResp.ProtoReflect.Descriptor instead. func (*GetMaxAndMinSeqResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{11} -} -func (m *GetMaxAndMinSeqResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetMaxAndMinSeqResp.Unmarshal(m, b) -} -func (m *GetMaxAndMinSeqResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetMaxAndMinSeqResp.Marshal(b, m, deterministic) -} -func (dst *GetMaxAndMinSeqResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetMaxAndMinSeqResp.Merge(dst, src) -} -func (m *GetMaxAndMinSeqResp) XXX_Size() int { - return xxx_messageInfo_GetMaxAndMinSeqResp.Size(m) -} -func (m *GetMaxAndMinSeqResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetMaxAndMinSeqResp.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{11} } -var xxx_messageInfo_GetMaxAndMinSeqResp proto.InternalMessageInfo - -func (m *GetMaxAndMinSeqResp) GetMaxSeq() uint32 { - if m != nil { - return m.MaxSeq +func (x *GetMaxAndMinSeqResp) GetMaxSeq() uint32 { + if x != nil { + return x.MaxSeq } return 0 } -func (m *GetMaxAndMinSeqResp) GetMinSeq() uint32 { - if m != nil { - return m.MinSeq +func (x *GetMaxAndMinSeqResp) GetMinSeq() uint32 { + if x != nil { + return x.MinSeq } return 0 } type UserSendMsgResp struct { - ServerMsgID string `protobuf:"bytes,1,opt,name=serverMsgID" json:"serverMsgID,omitempty"` - ClientMsgID string `protobuf:"bytes,2,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - SendTime int64 `protobuf:"varint,3,opt,name=sendTime" json:"sendTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ServerMsgID string `protobuf:"bytes,1,opt,name=serverMsgID,proto3" json:"serverMsgID,omitempty"` + ClientMsgID string `protobuf:"bytes,2,opt,name=clientMsgID,proto3" json:"clientMsgID,omitempty"` + SendTime int64 `protobuf:"varint,3,opt,name=sendTime,proto3" json:"sendTime,omitempty"` } -func (m *UserSendMsgResp) Reset() { *m = UserSendMsgResp{} } -func (m *UserSendMsgResp) String() string { return proto.CompactTextString(m) } -func (*UserSendMsgResp) ProtoMessage() {} +func (x *UserSendMsgResp) Reset() { + *x = UserSendMsgResp{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserSendMsgResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserSendMsgResp) ProtoMessage() {} + +func (x *UserSendMsgResp) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserSendMsgResp.ProtoReflect.Descriptor instead. func (*UserSendMsgResp) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{12} -} -func (m *UserSendMsgResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserSendMsgResp.Unmarshal(m, b) -} -func (m *UserSendMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserSendMsgResp.Marshal(b, m, deterministic) -} -func (dst *UserSendMsgResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserSendMsgResp.Merge(dst, src) -} -func (m *UserSendMsgResp) XXX_Size() int { - return xxx_messageInfo_UserSendMsgResp.Size(m) -} -func (m *UserSendMsgResp) XXX_DiscardUnknown() { - xxx_messageInfo_UserSendMsgResp.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{12} } -var xxx_messageInfo_UserSendMsgResp proto.InternalMessageInfo - -func (m *UserSendMsgResp) GetServerMsgID() string { - if m != nil { - return m.ServerMsgID +func (x *UserSendMsgResp) GetServerMsgID() string { + if x != nil { + return x.ServerMsgID } return "" } -func (m *UserSendMsgResp) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID +func (x *UserSendMsgResp) GetClientMsgID() string { + if x != nil { + return x.ClientMsgID } return "" } -func (m *UserSendMsgResp) GetSendTime() int64 { - if m != nil { - return m.SendTime +func (x *UserSendMsgResp) GetSendTime() int64 { + if x != nil { + return x.SendTime } return 0 } type MsgData struct { - SendID string `protobuf:"bytes,1,opt,name=sendID" json:"sendID,omitempty"` - RecvID string `protobuf:"bytes,2,opt,name=recvID" json:"recvID,omitempty"` - GroupID string `protobuf:"bytes,3,opt,name=groupID" json:"groupID,omitempty"` - ClientMsgID string `protobuf:"bytes,4,opt,name=clientMsgID" json:"clientMsgID,omitempty"` - ServerMsgID string `protobuf:"bytes,5,opt,name=serverMsgID" json:"serverMsgID,omitempty"` - SenderPlatformID int32 `protobuf:"varint,6,opt,name=senderPlatformID" json:"senderPlatformID,omitempty"` - SenderNickname string `protobuf:"bytes,7,opt,name=senderNickname" json:"senderNickname,omitempty"` - SenderFaceURL string `protobuf:"bytes,8,opt,name=senderFaceURL" json:"senderFaceURL,omitempty"` - SessionType int32 `protobuf:"varint,9,opt,name=sessionType" json:"sessionType,omitempty"` - MsgFrom int32 `protobuf:"varint,10,opt,name=msgFrom" json:"msgFrom,omitempty"` - ContentType int32 `protobuf:"varint,11,opt,name=contentType" json:"contentType,omitempty"` - Content []byte `protobuf:"bytes,12,opt,name=content,proto3" json:"content,omitempty"` - Seq uint32 `protobuf:"varint,14,opt,name=seq" json:"seq,omitempty"` - SendTime int64 `protobuf:"varint,15,opt,name=sendTime" json:"sendTime,omitempty"` - CreateTime int64 `protobuf:"varint,16,opt,name=createTime" json:"createTime,omitempty"` - Status int32 `protobuf:"varint,17,opt,name=status" json:"status,omitempty"` - Options map[string]bool `protobuf:"bytes,18,rep,name=options" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"` - OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,19,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SendID string `protobuf:"bytes,1,opt,name=sendID,proto3" json:"sendID,omitempty"` + RecvID string `protobuf:"bytes,2,opt,name=recvID,proto3" json:"recvID,omitempty"` + GroupID string `protobuf:"bytes,3,opt,name=groupID,proto3" json:"groupID,omitempty"` + ClientMsgID string `protobuf:"bytes,4,opt,name=clientMsgID,proto3" json:"clientMsgID,omitempty"` + ServerMsgID string `protobuf:"bytes,5,opt,name=serverMsgID,proto3" json:"serverMsgID,omitempty"` + SenderPlatformID int32 `protobuf:"varint,6,opt,name=senderPlatformID,proto3" json:"senderPlatformID,omitempty"` + SenderNickname string `protobuf:"bytes,7,opt,name=senderNickname,proto3" json:"senderNickname,omitempty"` + SenderFaceURL string `protobuf:"bytes,8,opt,name=senderFaceURL,proto3" json:"senderFaceURL,omitempty"` + SessionType int32 `protobuf:"varint,9,opt,name=sessionType,proto3" json:"sessionType,omitempty"` + MsgFrom int32 `protobuf:"varint,10,opt,name=msgFrom,proto3" json:"msgFrom,omitempty"` + ContentType int32 `protobuf:"varint,11,opt,name=contentType,proto3" json:"contentType,omitempty"` + Content []byte `protobuf:"bytes,12,opt,name=content,proto3" json:"content,omitempty"` + Seq uint32 `protobuf:"varint,14,opt,name=seq,proto3" json:"seq,omitempty"` + SendTime int64 `protobuf:"varint,15,opt,name=sendTime,proto3" json:"sendTime,omitempty"` + CreateTime int64 `protobuf:"varint,16,opt,name=createTime,proto3" json:"createTime,omitempty"` + Status int32 `protobuf:"varint,17,opt,name=status,proto3" json:"status,omitempty"` + Options map[string]bool `protobuf:"bytes,18,rep,name=options,proto3" json:"options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + OfflinePushInfo *OfflinePushInfo `protobuf:"bytes,19,opt,name=offlinePushInfo,proto3" json:"offlinePushInfo,omitempty"` } -func (m *MsgData) Reset() { *m = MsgData{} } -func (m *MsgData) String() string { return proto.CompactTextString(m) } -func (*MsgData) ProtoMessage() {} +func (x *MsgData) Reset() { + *x = MsgData{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MsgData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MsgData) ProtoMessage() {} + +func (x *MsgData) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MsgData.ProtoReflect.Descriptor instead. func (*MsgData) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{13} -} -func (m *MsgData) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MsgData.Unmarshal(m, b) -} -func (m *MsgData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MsgData.Marshal(b, m, deterministic) -} -func (dst *MsgData) XXX_Merge(src proto.Message) { - xxx_messageInfo_MsgData.Merge(dst, src) -} -func (m *MsgData) XXX_Size() int { - return xxx_messageInfo_MsgData.Size(m) -} -func (m *MsgData) XXX_DiscardUnknown() { - xxx_messageInfo_MsgData.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{13} } -var xxx_messageInfo_MsgData proto.InternalMessageInfo - -func (m *MsgData) GetSendID() string { - if m != nil { - return m.SendID +func (x *MsgData) GetSendID() string { + if x != nil { + return x.SendID } return "" } -func (m *MsgData) GetRecvID() string { - if m != nil { - return m.RecvID +func (x *MsgData) GetRecvID() string { + if x != nil { + return x.RecvID } return "" } -func (m *MsgData) GetGroupID() string { - if m != nil { - return m.GroupID +func (x *MsgData) GetGroupID() string { + if x != nil { + return x.GroupID } return "" } -func (m *MsgData) GetClientMsgID() string { - if m != nil { - return m.ClientMsgID +func (x *MsgData) GetClientMsgID() string { + if x != nil { + return x.ClientMsgID } return "" } -func (m *MsgData) GetServerMsgID() string { - if m != nil { - return m.ServerMsgID +func (x *MsgData) GetServerMsgID() string { + if x != nil { + return x.ServerMsgID } return "" } -func (m *MsgData) GetSenderPlatformID() int32 { - if m != nil { - return m.SenderPlatformID +func (x *MsgData) GetSenderPlatformID() int32 { + if x != nil { + return x.SenderPlatformID } return 0 } -func (m *MsgData) GetSenderNickname() string { - if m != nil { - return m.SenderNickname +func (x *MsgData) GetSenderNickname() string { + if x != nil { + return x.SenderNickname } return "" } -func (m *MsgData) GetSenderFaceURL() string { - if m != nil { - return m.SenderFaceURL +func (x *MsgData) GetSenderFaceURL() string { + if x != nil { + return x.SenderFaceURL } return "" } -func (m *MsgData) GetSessionType() int32 { - if m != nil { - return m.SessionType +func (x *MsgData) GetSessionType() int32 { + if x != nil { + return x.SessionType } return 0 } -func (m *MsgData) GetMsgFrom() int32 { - if m != nil { - return m.MsgFrom +func (x *MsgData) GetMsgFrom() int32 { + if x != nil { + return x.MsgFrom } return 0 } -func (m *MsgData) GetContentType() int32 { - if m != nil { - return m.ContentType +func (x *MsgData) GetContentType() int32 { + if x != nil { + return x.ContentType } return 0 } -func (m *MsgData) GetContent() []byte { - if m != nil { - return m.Content +func (x *MsgData) GetContent() []byte { + if x != nil { + return x.Content } return nil } -func (m *MsgData) GetSeq() uint32 { - if m != nil { - return m.Seq +func (x *MsgData) GetSeq() uint32 { + if x != nil { + return x.Seq } return 0 } -func (m *MsgData) GetSendTime() int64 { - if m != nil { - return m.SendTime +func (x *MsgData) GetSendTime() int64 { + if x != nil { + return x.SendTime } return 0 } -func (m *MsgData) GetCreateTime() int64 { - if m != nil { - return m.CreateTime +func (x *MsgData) GetCreateTime() int64 { + if x != nil { + return x.CreateTime } return 0 } -func (m *MsgData) GetStatus() int32 { - if m != nil { - return m.Status +func (x *MsgData) GetStatus() int32 { + if x != nil { + return x.Status } return 0 } -func (m *MsgData) GetOptions() map[string]bool { - if m != nil { - return m.Options +func (x *MsgData) GetOptions() map[string]bool { + if x != nil { + return x.Options } return nil } -func (m *MsgData) GetOfflinePushInfo() *OfflinePushInfo { - if m != nil { - return m.OfflinePushInfo +func (x *MsgData) GetOfflinePushInfo() *OfflinePushInfo { + if x != nil { + return x.OfflinePushInfo } return nil } type OfflinePushInfo struct { - Title string `protobuf:"bytes,1,opt,name=title" json:"title,omitempty"` - Desc string `protobuf:"bytes,2,opt,name=desc" json:"desc,omitempty"` - Ex string `protobuf:"bytes,3,opt,name=ex" json:"ex,omitempty"` - IOSPushSound string `protobuf:"bytes,4,opt,name=iOSPushSound" json:"iOSPushSound,omitempty"` - IOSBadgeCount bool `protobuf:"varint,5,opt,name=iOSBadgeCount" json:"iOSBadgeCount,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"` + Desc string `protobuf:"bytes,2,opt,name=desc,proto3" json:"desc,omitempty"` + Ex string `protobuf:"bytes,3,opt,name=ex,proto3" json:"ex,omitempty"` + IOSPushSound string `protobuf:"bytes,4,opt,name=iOSPushSound,proto3" json:"iOSPushSound,omitempty"` + IOSBadgeCount bool `protobuf:"varint,5,opt,name=iOSBadgeCount,proto3" json:"iOSBadgeCount,omitempty"` } -func (m *OfflinePushInfo) Reset() { *m = OfflinePushInfo{} } -func (m *OfflinePushInfo) String() string { return proto.CompactTextString(m) } -func (*OfflinePushInfo) ProtoMessage() {} +func (x *OfflinePushInfo) Reset() { + *x = OfflinePushInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OfflinePushInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OfflinePushInfo) ProtoMessage() {} + +func (x *OfflinePushInfo) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OfflinePushInfo.ProtoReflect.Descriptor instead. func (*OfflinePushInfo) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{14} -} -func (m *OfflinePushInfo) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OfflinePushInfo.Unmarshal(m, b) -} -func (m *OfflinePushInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OfflinePushInfo.Marshal(b, m, deterministic) -} -func (dst *OfflinePushInfo) XXX_Merge(src proto.Message) { - xxx_messageInfo_OfflinePushInfo.Merge(dst, src) -} -func (m *OfflinePushInfo) XXX_Size() int { - return xxx_messageInfo_OfflinePushInfo.Size(m) -} -func (m *OfflinePushInfo) XXX_DiscardUnknown() { - xxx_messageInfo_OfflinePushInfo.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{14} } -var xxx_messageInfo_OfflinePushInfo proto.InternalMessageInfo - -func (m *OfflinePushInfo) GetTitle() string { - if m != nil { - return m.Title +func (x *OfflinePushInfo) GetTitle() string { + if x != nil { + return x.Title } return "" } -func (m *OfflinePushInfo) GetDesc() string { - if m != nil { - return m.Desc +func (x *OfflinePushInfo) GetDesc() string { + if x != nil { + return x.Desc } return "" } -func (m *OfflinePushInfo) GetEx() string { - if m != nil { - return m.Ex +func (x *OfflinePushInfo) GetEx() string { + if x != nil { + return x.Ex } return "" } -func (m *OfflinePushInfo) GetIOSPushSound() string { - if m != nil { - return m.IOSPushSound +func (x *OfflinePushInfo) GetIOSPushSound() string { + if x != nil { + return x.IOSPushSound } return "" } -func (m *OfflinePushInfo) GetIOSBadgeCount() bool { - if m != nil { - return m.IOSBadgeCount +func (x *OfflinePushInfo) GetIOSBadgeCount() bool { + if x != nil { + return x.IOSBadgeCount } return false } type TipsComm struct { - Detail []byte `protobuf:"bytes,1,opt,name=detail,proto3" json:"detail,omitempty"` - DefaultTips string `protobuf:"bytes,2,opt,name=defaultTips" json:"defaultTips,omitempty"` - JsonDetail string `protobuf:"bytes,3,opt,name=jsonDetail" json:"jsonDetail,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Detail []byte `protobuf:"bytes,1,opt,name=detail,proto3" json:"detail,omitempty"` + DefaultTips string `protobuf:"bytes,2,opt,name=defaultTips,proto3" json:"defaultTips,omitempty"` + JsonDetail string `protobuf:"bytes,3,opt,name=jsonDetail,proto3" json:"jsonDetail,omitempty"` } -func (m *TipsComm) Reset() { *m = TipsComm{} } -func (m *TipsComm) String() string { return proto.CompactTextString(m) } -func (*TipsComm) ProtoMessage() {} +func (x *TipsComm) Reset() { + *x = TipsComm{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TipsComm) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TipsComm) ProtoMessage() {} + +func (x *TipsComm) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TipsComm.ProtoReflect.Descriptor instead. func (*TipsComm) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{15} -} -func (m *TipsComm) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_TipsComm.Unmarshal(m, b) -} -func (m *TipsComm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_TipsComm.Marshal(b, m, deterministic) -} -func (dst *TipsComm) XXX_Merge(src proto.Message) { - xxx_messageInfo_TipsComm.Merge(dst, src) -} -func (m *TipsComm) XXX_Size() int { - return xxx_messageInfo_TipsComm.Size(m) -} -func (m *TipsComm) XXX_DiscardUnknown() { - xxx_messageInfo_TipsComm.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{15} } -var xxx_messageInfo_TipsComm proto.InternalMessageInfo - -func (m *TipsComm) GetDetail() []byte { - if m != nil { - return m.Detail +func (x *TipsComm) GetDetail() []byte { + if x != nil { + return x.Detail } return nil } -func (m *TipsComm) GetDefaultTips() string { - if m != nil { - return m.DefaultTips +func (x *TipsComm) GetDefaultTips() string { + if x != nil { + return x.DefaultTips } return "" } -func (m *TipsComm) GetJsonDetail() string { - if m != nil { - return m.JsonDetail +func (x *TipsComm) GetJsonDetail() string { + if x != nil { + return x.JsonDetail } return "" } -// OnGroupCreated() +// OnGroupCreated() type GroupCreatedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - MemberList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=memberList" json:"memberList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - GroupOwnerUser *GroupMemberFullInfo `protobuf:"bytes,5,opt,name=groupOwnerUser" json:"groupOwnerUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + MemberList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=memberList,proto3" json:"memberList,omitempty"` + OperationTime int64 `protobuf:"varint,4,opt,name=operationTime,proto3" json:"operationTime,omitempty"` + GroupOwnerUser *GroupMemberFullInfo `protobuf:"bytes,5,opt,name=groupOwnerUser,proto3" json:"groupOwnerUser,omitempty"` } -func (m *GroupCreatedTips) Reset() { *m = GroupCreatedTips{} } -func (m *GroupCreatedTips) String() string { return proto.CompactTextString(m) } -func (*GroupCreatedTips) ProtoMessage() {} +func (x *GroupCreatedTips) Reset() { + *x = GroupCreatedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupCreatedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupCreatedTips) ProtoMessage() {} + +func (x *GroupCreatedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupCreatedTips.ProtoReflect.Descriptor instead. func (*GroupCreatedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{16} -} -func (m *GroupCreatedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupCreatedTips.Unmarshal(m, b) -} -func (m *GroupCreatedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupCreatedTips.Marshal(b, m, deterministic) -} -func (dst *GroupCreatedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupCreatedTips.Merge(dst, src) -} -func (m *GroupCreatedTips) XXX_Size() int { - return xxx_messageInfo_GroupCreatedTips.Size(m) -} -func (m *GroupCreatedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupCreatedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{16} } -var xxx_messageInfo_GroupCreatedTips proto.InternalMessageInfo - -func (m *GroupCreatedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *GroupCreatedTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *GroupCreatedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *GroupCreatedTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *GroupCreatedTips) GetMemberList() []*GroupMemberFullInfo { - if m != nil { - return m.MemberList +func (x *GroupCreatedTips) GetMemberList() []*GroupMemberFullInfo { + if x != nil { + return x.MemberList } return nil } -func (m *GroupCreatedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *GroupCreatedTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -func (m *GroupCreatedTips) GetGroupOwnerUser() *GroupMemberFullInfo { - if m != nil { - return m.GroupOwnerUser +func (x *GroupCreatedTips) GetGroupOwnerUser() *GroupMemberFullInfo { + if x != nil { + return x.GroupOwnerUser } return nil } -// OnGroupInfoSet() +// OnGroupInfoSet() type GroupInfoSetTips struct { - OpUser *GroupMemberFullInfo `protobuf:"bytes,1,opt,name=opUser" json:"opUser,omitempty"` - MuteTime int64 `protobuf:"varint,2,opt,name=muteTime" json:"muteTime,omitempty"` - Group *GroupInfo `protobuf:"bytes,3,opt,name=group" json:"group,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OpUser *GroupMemberFullInfo `protobuf:"bytes,1,opt,name=opUser,proto3" json:"opUser,omitempty"` //who do this + MuteTime int64 `protobuf:"varint,2,opt,name=muteTime,proto3" json:"muteTime,omitempty"` + Group *GroupInfo `protobuf:"bytes,3,opt,name=group,proto3" json:"group,omitempty"` } -func (m *GroupInfoSetTips) Reset() { *m = GroupInfoSetTips{} } -func (m *GroupInfoSetTips) String() string { return proto.CompactTextString(m) } -func (*GroupInfoSetTips) ProtoMessage() {} +func (x *GroupInfoSetTips) Reset() { + *x = GroupInfoSetTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupInfoSetTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupInfoSetTips) ProtoMessage() {} + +func (x *GroupInfoSetTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupInfoSetTips.ProtoReflect.Descriptor instead. func (*GroupInfoSetTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{17} -} -func (m *GroupInfoSetTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupInfoSetTips.Unmarshal(m, b) -} -func (m *GroupInfoSetTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupInfoSetTips.Marshal(b, m, deterministic) -} -func (dst *GroupInfoSetTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupInfoSetTips.Merge(dst, src) -} -func (m *GroupInfoSetTips) XXX_Size() int { - return xxx_messageInfo_GroupInfoSetTips.Size(m) -} -func (m *GroupInfoSetTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupInfoSetTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{17} } -var xxx_messageInfo_GroupInfoSetTips proto.InternalMessageInfo - -func (m *GroupInfoSetTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *GroupInfoSetTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *GroupInfoSetTips) GetMuteTime() int64 { - if m != nil { - return m.MuteTime +func (x *GroupInfoSetTips) GetMuteTime() int64 { + if x != nil { + return x.MuteTime } return 0 } -func (m *GroupInfoSetTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *GroupInfoSetTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -// OnJoinGroupApplication() +// OnJoinGroupApplication() type JoinGroupApplicationTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - Applicant *PublicUserInfo `protobuf:"bytes,2,opt,name=applicant" json:"applicant,omitempty"` - ReqMsg string `protobuf:"bytes,3,opt,name=reqMsg" json:"reqMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + Applicant *PublicUserInfo `protobuf:"bytes,2,opt,name=applicant,proto3" json:"applicant,omitempty"` + ReqMsg string `protobuf:"bytes,3,opt,name=reqMsg,proto3" json:"reqMsg,omitempty"` } -func (m *JoinGroupApplicationTips) Reset() { *m = JoinGroupApplicationTips{} } -func (m *JoinGroupApplicationTips) String() string { return proto.CompactTextString(m) } -func (*JoinGroupApplicationTips) ProtoMessage() {} +func (x *JoinGroupApplicationTips) Reset() { + *x = JoinGroupApplicationTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *JoinGroupApplicationTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JoinGroupApplicationTips) ProtoMessage() {} + +func (x *JoinGroupApplicationTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JoinGroupApplicationTips.ProtoReflect.Descriptor instead. func (*JoinGroupApplicationTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{18} -} -func (m *JoinGroupApplicationTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_JoinGroupApplicationTips.Unmarshal(m, b) -} -func (m *JoinGroupApplicationTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_JoinGroupApplicationTips.Marshal(b, m, deterministic) -} -func (dst *JoinGroupApplicationTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_JoinGroupApplicationTips.Merge(dst, src) -} -func (m *JoinGroupApplicationTips) XXX_Size() int { - return xxx_messageInfo_JoinGroupApplicationTips.Size(m) -} -func (m *JoinGroupApplicationTips) XXX_DiscardUnknown() { - xxx_messageInfo_JoinGroupApplicationTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{18} } -var xxx_messageInfo_JoinGroupApplicationTips proto.InternalMessageInfo - -func (m *JoinGroupApplicationTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *JoinGroupApplicationTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *JoinGroupApplicationTips) GetApplicant() *PublicUserInfo { - if m != nil { - return m.Applicant +func (x *JoinGroupApplicationTips) GetApplicant() *PublicUserInfo { + if x != nil { + return x.Applicant } return nil } -func (m *JoinGroupApplicationTips) GetReqMsg() string { - if m != nil { - return m.ReqMsg +func (x *JoinGroupApplicationTips) GetReqMsg() string { + if x != nil { + return x.ReqMsg } return "" } -// OnQuitGroup() -// Actively leave the group +// OnQuitGroup() +//Actively leave the group type MemberQuitTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - QuitUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=quitUser" json:"quitUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + QuitUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=quitUser,proto3" json:"quitUser,omitempty"` + OperationTime int64 `protobuf:"varint,3,opt,name=operationTime,proto3" json:"operationTime,omitempty"` } -func (m *MemberQuitTips) Reset() { *m = MemberQuitTips{} } -func (m *MemberQuitTips) String() string { return proto.CompactTextString(m) } -func (*MemberQuitTips) ProtoMessage() {} +func (x *MemberQuitTips) Reset() { + *x = MemberQuitTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MemberQuitTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MemberQuitTips) ProtoMessage() {} + +func (x *MemberQuitTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MemberQuitTips.ProtoReflect.Descriptor instead. func (*MemberQuitTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{19} -} -func (m *MemberQuitTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberQuitTips.Unmarshal(m, b) -} -func (m *MemberQuitTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberQuitTips.Marshal(b, m, deterministic) -} -func (dst *MemberQuitTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberQuitTips.Merge(dst, src) -} -func (m *MemberQuitTips) XXX_Size() int { - return xxx_messageInfo_MemberQuitTips.Size(m) -} -func (m *MemberQuitTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberQuitTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{19} } -var xxx_messageInfo_MemberQuitTips proto.InternalMessageInfo - -func (m *MemberQuitTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *MemberQuitTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *MemberQuitTips) GetQuitUser() *GroupMemberFullInfo { - if m != nil { - return m.QuitUser +func (x *MemberQuitTips) GetQuitUser() *GroupMemberFullInfo { + if x != nil { + return x.QuitUser } return nil } -func (m *MemberQuitTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *MemberQuitTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -// OnApplicationGroupAccepted() +// OnApplicationGroupAccepted() type GroupApplicationAcceptedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` } -func (m *GroupApplicationAcceptedTips) Reset() { *m = GroupApplicationAcceptedTips{} } -func (m *GroupApplicationAcceptedTips) String() string { return proto.CompactTextString(m) } -func (*GroupApplicationAcceptedTips) ProtoMessage() {} +func (x *GroupApplicationAcceptedTips) Reset() { + *x = GroupApplicationAcceptedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupApplicationAcceptedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupApplicationAcceptedTips) ProtoMessage() {} + +func (x *GroupApplicationAcceptedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupApplicationAcceptedTips.ProtoReflect.Descriptor instead. func (*GroupApplicationAcceptedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{20} -} -func (m *GroupApplicationAcceptedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupApplicationAcceptedTips.Unmarshal(m, b) -} -func (m *GroupApplicationAcceptedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupApplicationAcceptedTips.Marshal(b, m, deterministic) -} -func (dst *GroupApplicationAcceptedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupApplicationAcceptedTips.Merge(dst, src) -} -func (m *GroupApplicationAcceptedTips) XXX_Size() int { - return xxx_messageInfo_GroupApplicationAcceptedTips.Size(m) -} -func (m *GroupApplicationAcceptedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupApplicationAcceptedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{20} } -var xxx_messageInfo_GroupApplicationAcceptedTips proto.InternalMessageInfo - -func (m *GroupApplicationAcceptedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *GroupApplicationAcceptedTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *GroupApplicationAcceptedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *GroupApplicationAcceptedTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *GroupApplicationAcceptedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *GroupApplicationAcceptedTips) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } -// OnApplicationGroupRejected() +// OnApplicationGroupRejected() type GroupApplicationRejectedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + HandleMsg string `protobuf:"bytes,4,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` } -func (m *GroupApplicationRejectedTips) Reset() { *m = GroupApplicationRejectedTips{} } -func (m *GroupApplicationRejectedTips) String() string { return proto.CompactTextString(m) } -func (*GroupApplicationRejectedTips) ProtoMessage() {} +func (x *GroupApplicationRejectedTips) Reset() { + *x = GroupApplicationRejectedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupApplicationRejectedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupApplicationRejectedTips) ProtoMessage() {} + +func (x *GroupApplicationRejectedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupApplicationRejectedTips.ProtoReflect.Descriptor instead. func (*GroupApplicationRejectedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{21} -} -func (m *GroupApplicationRejectedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupApplicationRejectedTips.Unmarshal(m, b) -} -func (m *GroupApplicationRejectedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupApplicationRejectedTips.Marshal(b, m, deterministic) -} -func (dst *GroupApplicationRejectedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupApplicationRejectedTips.Merge(dst, src) -} -func (m *GroupApplicationRejectedTips) XXX_Size() int { - return xxx_messageInfo_GroupApplicationRejectedTips.Size(m) -} -func (m *GroupApplicationRejectedTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupApplicationRejectedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{21} } -var xxx_messageInfo_GroupApplicationRejectedTips proto.InternalMessageInfo - -func (m *GroupApplicationRejectedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *GroupApplicationRejectedTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *GroupApplicationRejectedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *GroupApplicationRejectedTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *GroupApplicationRejectedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *GroupApplicationRejectedTips) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } -// OnTransferGroupOwner() +// OnTransferGroupOwner() type GroupOwnerTransferredTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - NewGroupOwner *GroupMemberFullInfo `protobuf:"bytes,3,opt,name=newGroupOwner" json:"newGroupOwner,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + NewGroupOwner *GroupMemberFullInfo `protobuf:"bytes,3,opt,name=newGroupOwner,proto3" json:"newGroupOwner,omitempty"` + OperationTime int64 `protobuf:"varint,4,opt,name=operationTime,proto3" json:"operationTime,omitempty"` } -func (m *GroupOwnerTransferredTips) Reset() { *m = GroupOwnerTransferredTips{} } -func (m *GroupOwnerTransferredTips) String() string { return proto.CompactTextString(m) } -func (*GroupOwnerTransferredTips) ProtoMessage() {} +func (x *GroupOwnerTransferredTips) Reset() { + *x = GroupOwnerTransferredTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupOwnerTransferredTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupOwnerTransferredTips) ProtoMessage() {} + +func (x *GroupOwnerTransferredTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupOwnerTransferredTips.ProtoReflect.Descriptor instead. func (*GroupOwnerTransferredTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{22} -} -func (m *GroupOwnerTransferredTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GroupOwnerTransferredTips.Unmarshal(m, b) -} -func (m *GroupOwnerTransferredTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GroupOwnerTransferredTips.Marshal(b, m, deterministic) -} -func (dst *GroupOwnerTransferredTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_GroupOwnerTransferredTips.Merge(dst, src) -} -func (m *GroupOwnerTransferredTips) XXX_Size() int { - return xxx_messageInfo_GroupOwnerTransferredTips.Size(m) -} -func (m *GroupOwnerTransferredTips) XXX_DiscardUnknown() { - xxx_messageInfo_GroupOwnerTransferredTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{22} } -var xxx_messageInfo_GroupOwnerTransferredTips proto.InternalMessageInfo - -func (m *GroupOwnerTransferredTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *GroupOwnerTransferredTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *GroupOwnerTransferredTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *GroupOwnerTransferredTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *GroupOwnerTransferredTips) GetNewGroupOwner() *GroupMemberFullInfo { - if m != nil { - return m.NewGroupOwner +func (x *GroupOwnerTransferredTips) GetNewGroupOwner() *GroupMemberFullInfo { + if x != nil { + return x.NewGroupOwner } return nil } -func (m *GroupOwnerTransferredTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *GroupOwnerTransferredTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -// OnMemberKicked() +// OnMemberKicked() type MemberKickedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - KickedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=kickedUserList" json:"kickedUserList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + KickedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=kickedUserList,proto3" json:"kickedUserList,omitempty"` + OperationTime int64 `protobuf:"varint,4,opt,name=operationTime,proto3" json:"operationTime,omitempty"` } -func (m *MemberKickedTips) Reset() { *m = MemberKickedTips{} } -func (m *MemberKickedTips) String() string { return proto.CompactTextString(m) } -func (*MemberKickedTips) ProtoMessage() {} +func (x *MemberKickedTips) Reset() { + *x = MemberKickedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MemberKickedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MemberKickedTips) ProtoMessage() {} + +func (x *MemberKickedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MemberKickedTips.ProtoReflect.Descriptor instead. func (*MemberKickedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{23} -} -func (m *MemberKickedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberKickedTips.Unmarshal(m, b) -} -func (m *MemberKickedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberKickedTips.Marshal(b, m, deterministic) -} -func (dst *MemberKickedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberKickedTips.Merge(dst, src) -} -func (m *MemberKickedTips) XXX_Size() int { - return xxx_messageInfo_MemberKickedTips.Size(m) -} -func (m *MemberKickedTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberKickedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{23} } -var xxx_messageInfo_MemberKickedTips proto.InternalMessageInfo - -func (m *MemberKickedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *MemberKickedTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *MemberKickedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *MemberKickedTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *MemberKickedTips) GetKickedUserList() []*GroupMemberFullInfo { - if m != nil { - return m.KickedUserList +func (x *MemberKickedTips) GetKickedUserList() []*GroupMemberFullInfo { + if x != nil { + return x.KickedUserList } return nil } -func (m *MemberKickedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *MemberKickedTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -// OnMemberInvited() +// OnMemberInvited() type MemberInvitedTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser" json:"opUser,omitempty"` - InvitedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=invitedUserList" json:"invitedUserList,omitempty"` - OperationTime int64 `protobuf:"varint,4,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + OpUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=opUser,proto3" json:"opUser,omitempty"` + InvitedUserList []*GroupMemberFullInfo `protobuf:"bytes,3,rep,name=invitedUserList,proto3" json:"invitedUserList,omitempty"` + OperationTime int64 `protobuf:"varint,4,opt,name=operationTime,proto3" json:"operationTime,omitempty"` } -func (m *MemberInvitedTips) Reset() { *m = MemberInvitedTips{} } -func (m *MemberInvitedTips) String() string { return proto.CompactTextString(m) } -func (*MemberInvitedTips) ProtoMessage() {} +func (x *MemberInvitedTips) Reset() { + *x = MemberInvitedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MemberInvitedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MemberInvitedTips) ProtoMessage() {} + +func (x *MemberInvitedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MemberInvitedTips.ProtoReflect.Descriptor instead. func (*MemberInvitedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{24} -} -func (m *MemberInvitedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberInvitedTips.Unmarshal(m, b) -} -func (m *MemberInvitedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberInvitedTips.Marshal(b, m, deterministic) -} -func (dst *MemberInvitedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberInvitedTips.Merge(dst, src) -} -func (m *MemberInvitedTips) XXX_Size() int { - return xxx_messageInfo_MemberInvitedTips.Size(m) -} -func (m *MemberInvitedTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberInvitedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{24} } -var xxx_messageInfo_MemberInvitedTips proto.InternalMessageInfo - -func (m *MemberInvitedTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *MemberInvitedTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *MemberInvitedTips) GetOpUser() *GroupMemberFullInfo { - if m != nil { - return m.OpUser +func (x *MemberInvitedTips) GetOpUser() *GroupMemberFullInfo { + if x != nil { + return x.OpUser } return nil } -func (m *MemberInvitedTips) GetInvitedUserList() []*GroupMemberFullInfo { - if m != nil { - return m.InvitedUserList +func (x *MemberInvitedTips) GetInvitedUserList() []*GroupMemberFullInfo { + if x != nil { + return x.InvitedUserList } return nil } -func (m *MemberInvitedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *MemberInvitedTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -// Actively join the group +//Actively join the group type MemberEnterTips struct { - Group *GroupInfo `protobuf:"bytes,1,opt,name=group" json:"group,omitempty"` - EntrantUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=entrantUser" json:"entrantUser,omitempty"` - OperationTime int64 `protobuf:"varint,3,opt,name=operationTime" json:"operationTime,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Group *GroupInfo `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + EntrantUser *GroupMemberFullInfo `protobuf:"bytes,2,opt,name=entrantUser,proto3" json:"entrantUser,omitempty"` + OperationTime int64 `protobuf:"varint,3,opt,name=operationTime,proto3" json:"operationTime,omitempty"` } -func (m *MemberEnterTips) Reset() { *m = MemberEnterTips{} } -func (m *MemberEnterTips) String() string { return proto.CompactTextString(m) } -func (*MemberEnterTips) ProtoMessage() {} +func (x *MemberEnterTips) Reset() { + *x = MemberEnterTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MemberEnterTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MemberEnterTips) ProtoMessage() {} + +func (x *MemberEnterTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MemberEnterTips.ProtoReflect.Descriptor instead. func (*MemberEnterTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{25} -} -func (m *MemberEnterTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_MemberEnterTips.Unmarshal(m, b) -} -func (m *MemberEnterTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_MemberEnterTips.Marshal(b, m, deterministic) -} -func (dst *MemberEnterTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_MemberEnterTips.Merge(dst, src) -} -func (m *MemberEnterTips) XXX_Size() int { - return xxx_messageInfo_MemberEnterTips.Size(m) -} -func (m *MemberEnterTips) XXX_DiscardUnknown() { - xxx_messageInfo_MemberEnterTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{25} } -var xxx_messageInfo_MemberEnterTips proto.InternalMessageInfo - -func (m *MemberEnterTips) GetGroup() *GroupInfo { - if m != nil { - return m.Group +func (x *MemberEnterTips) GetGroup() *GroupInfo { + if x != nil { + return x.Group } return nil } -func (m *MemberEnterTips) GetEntrantUser() *GroupMemberFullInfo { - if m != nil { - return m.EntrantUser +func (x *MemberEnterTips) GetEntrantUser() *GroupMemberFullInfo { + if x != nil { + return x.EntrantUser } return nil } -func (m *MemberEnterTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *MemberEnterTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } type FriendApplication struct { - AddTime int64 `protobuf:"varint,1,opt,name=addTime" json:"addTime,omitempty"` - AddSource string `protobuf:"bytes,2,opt,name=addSource" json:"addSource,omitempty"` - AddWording string `protobuf:"bytes,3,opt,name=addWording" json:"addWording,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AddTime int64 `protobuf:"varint,1,opt,name=addTime,proto3" json:"addTime,omitempty"` + AddSource string `protobuf:"bytes,2,opt,name=addSource,proto3" json:"addSource,omitempty"` + AddWording string `protobuf:"bytes,3,opt,name=addWording,proto3" json:"addWording,omitempty"` } -func (m *FriendApplication) Reset() { *m = FriendApplication{} } -func (m *FriendApplication) String() string { return proto.CompactTextString(m) } -func (*FriendApplication) ProtoMessage() {} +func (x *FriendApplication) Reset() { + *x = FriendApplication{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendApplication) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendApplication) ProtoMessage() {} + +func (x *FriendApplication) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendApplication.ProtoReflect.Descriptor instead. func (*FriendApplication) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{26} -} -func (m *FriendApplication) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplication.Unmarshal(m, b) -} -func (m *FriendApplication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplication.Marshal(b, m, deterministic) -} -func (dst *FriendApplication) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplication.Merge(dst, src) -} -func (m *FriendApplication) XXX_Size() int { - return xxx_messageInfo_FriendApplication.Size(m) -} -func (m *FriendApplication) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplication.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{26} } -var xxx_messageInfo_FriendApplication proto.InternalMessageInfo - -func (m *FriendApplication) GetAddTime() int64 { - if m != nil { - return m.AddTime +func (x *FriendApplication) GetAddTime() int64 { + if x != nil { + return x.AddTime } return 0 } -func (m *FriendApplication) GetAddSource() string { - if m != nil { - return m.AddSource +func (x *FriendApplication) GetAddSource() string { + if x != nil { + return x.AddSource } return "" } -func (m *FriendApplication) GetAddWording() string { - if m != nil { - return m.AddWording +func (x *FriendApplication) GetAddWording() string { + if x != nil { + return x.AddWording } return "" } type FromToUserID struct { - FromUserID string `protobuf:"bytes,1,opt,name=fromUserID" json:"fromUserID,omitempty"` - ToUserID string `protobuf:"bytes,2,opt,name=toUserID" json:"toUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromUserID string `protobuf:"bytes,1,opt,name=fromUserID,proto3" json:"fromUserID,omitempty"` + ToUserID string `protobuf:"bytes,2,opt,name=toUserID,proto3" json:"toUserID,omitempty"` } -func (m *FromToUserID) Reset() { *m = FromToUserID{} } -func (m *FromToUserID) String() string { return proto.CompactTextString(m) } -func (*FromToUserID) ProtoMessage() {} +func (x *FromToUserID) Reset() { + *x = FromToUserID{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FromToUserID) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FromToUserID) ProtoMessage() {} + +func (x *FromToUserID) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FromToUserID.ProtoReflect.Descriptor instead. func (*FromToUserID) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{27} -} -func (m *FromToUserID) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FromToUserID.Unmarshal(m, b) -} -func (m *FromToUserID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FromToUserID.Marshal(b, m, deterministic) -} -func (dst *FromToUserID) XXX_Merge(src proto.Message) { - xxx_messageInfo_FromToUserID.Merge(dst, src) -} -func (m *FromToUserID) XXX_Size() int { - return xxx_messageInfo_FromToUserID.Size(m) -} -func (m *FromToUserID) XXX_DiscardUnknown() { - xxx_messageInfo_FromToUserID.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{27} } -var xxx_messageInfo_FromToUserID proto.InternalMessageInfo - -func (m *FromToUserID) GetFromUserID() string { - if m != nil { - return m.FromUserID +func (x *FromToUserID) GetFromUserID() string { + if x != nil { + return x.FromUserID } return "" } -func (m *FromToUserID) GetToUserID() string { - if m != nil { - return m.ToUserID +func (x *FromToUserID) GetToUserID() string { + if x != nil { + return x.ToUserID } return "" } -// FromUserID apply to add ToUserID +//FromUserID apply to add ToUserID type FriendApplicationTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` } -func (m *FriendApplicationTips) Reset() { *m = FriendApplicationTips{} } -func (m *FriendApplicationTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationTips) ProtoMessage() {} +func (x *FriendApplicationTips) Reset() { + *x = FriendApplicationTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendApplicationTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendApplicationTips) ProtoMessage() {} + +func (x *FriendApplicationTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendApplicationTips.ProtoReflect.Descriptor instead. func (*FriendApplicationTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{28} -} -func (m *FriendApplicationTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationTips.Unmarshal(m, b) -} -func (m *FriendApplicationTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationTips.Merge(dst, src) -} -func (m *FriendApplicationTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationTips.Size(m) -} -func (m *FriendApplicationTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{28} } -var xxx_messageInfo_FriendApplicationTips proto.InternalMessageInfo - -func (m *FriendApplicationTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *FriendApplicationTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } -// FromUserID accept or reject ToUserID +//FromUserID accept or reject ToUserID type FriendApplicationApprovedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` + HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` } -func (m *FriendApplicationApprovedTips) Reset() { *m = FriendApplicationApprovedTips{} } -func (m *FriendApplicationApprovedTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationApprovedTips) ProtoMessage() {} +func (x *FriendApplicationApprovedTips) Reset() { + *x = FriendApplicationApprovedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendApplicationApprovedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendApplicationApprovedTips) ProtoMessage() {} + +func (x *FriendApplicationApprovedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendApplicationApprovedTips.ProtoReflect.Descriptor instead. func (*FriendApplicationApprovedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{29} -} -func (m *FriendApplicationApprovedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationApprovedTips.Unmarshal(m, b) -} -func (m *FriendApplicationApprovedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationApprovedTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationApprovedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationApprovedTips.Merge(dst, src) -} -func (m *FriendApplicationApprovedTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationApprovedTips.Size(m) -} -func (m *FriendApplicationApprovedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationApprovedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{29} } -var xxx_messageInfo_FriendApplicationApprovedTips proto.InternalMessageInfo - -func (m *FriendApplicationApprovedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *FriendApplicationApprovedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } -func (m *FriendApplicationApprovedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *FriendApplicationApprovedTips) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } -// FromUserID accept or reject ToUserID +//FromUserID accept or reject ToUserID type FriendApplicationRejectedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg" json:"handleMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` + HandleMsg string `protobuf:"bytes,2,opt,name=handleMsg,proto3" json:"handleMsg,omitempty"` } -func (m *FriendApplicationRejectedTips) Reset() { *m = FriendApplicationRejectedTips{} } -func (m *FriendApplicationRejectedTips) String() string { return proto.CompactTextString(m) } -func (*FriendApplicationRejectedTips) ProtoMessage() {} +func (x *FriendApplicationRejectedTips) Reset() { + *x = FriendApplicationRejectedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendApplicationRejectedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendApplicationRejectedTips) ProtoMessage() {} + +func (x *FriendApplicationRejectedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendApplicationRejectedTips.ProtoReflect.Descriptor instead. func (*FriendApplicationRejectedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{30} -} -func (m *FriendApplicationRejectedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendApplicationRejectedTips.Unmarshal(m, b) -} -func (m *FriendApplicationRejectedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendApplicationRejectedTips.Marshal(b, m, deterministic) -} -func (dst *FriendApplicationRejectedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendApplicationRejectedTips.Merge(dst, src) -} -func (m *FriendApplicationRejectedTips) XXX_Size() int { - return xxx_messageInfo_FriendApplicationRejectedTips.Size(m) -} -func (m *FriendApplicationRejectedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendApplicationRejectedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{30} } -var xxx_messageInfo_FriendApplicationRejectedTips proto.InternalMessageInfo - -func (m *FriendApplicationRejectedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *FriendApplicationRejectedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } -func (m *FriendApplicationRejectedTips) GetHandleMsg() string { - if m != nil { - return m.HandleMsg +func (x *FriendApplicationRejectedTips) GetHandleMsg() string { + if x != nil { + return x.HandleMsg } return "" } // FromUserID Added a friend ToUserID type FriendAddedTips struct { - Friend *FriendInfo `protobuf:"bytes,1,opt,name=friend" json:"friend,omitempty"` - OperationTime int64 `protobuf:"varint,2,opt,name=operationTime" json:"operationTime,omitempty"` - OpUser *PublicUserInfo `protobuf:"bytes,3,opt,name=opUser" json:"opUser,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Friend *FriendInfo `protobuf:"bytes,1,opt,name=friend,proto3" json:"friend,omitempty"` + OperationTime int64 `protobuf:"varint,2,opt,name=operationTime,proto3" json:"operationTime,omitempty"` + OpUser *PublicUserInfo `protobuf:"bytes,3,opt,name=opUser,proto3" json:"opUser,omitempty"` //who do this } -func (m *FriendAddedTips) Reset() { *m = FriendAddedTips{} } -func (m *FriendAddedTips) String() string { return proto.CompactTextString(m) } -func (*FriendAddedTips) ProtoMessage() {} +func (x *FriendAddedTips) Reset() { + *x = FriendAddedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendAddedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendAddedTips) ProtoMessage() {} + +func (x *FriendAddedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendAddedTips.ProtoReflect.Descriptor instead. func (*FriendAddedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{31} -} -func (m *FriendAddedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendAddedTips.Unmarshal(m, b) -} -func (m *FriendAddedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendAddedTips.Marshal(b, m, deterministic) -} -func (dst *FriendAddedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendAddedTips.Merge(dst, src) -} -func (m *FriendAddedTips) XXX_Size() int { - return xxx_messageInfo_FriendAddedTips.Size(m) -} -func (m *FriendAddedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendAddedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{31} } -var xxx_messageInfo_FriendAddedTips proto.InternalMessageInfo - -func (m *FriendAddedTips) GetFriend() *FriendInfo { - if m != nil { - return m.Friend +func (x *FriendAddedTips) GetFriend() *FriendInfo { + if x != nil { + return x.Friend } return nil } -func (m *FriendAddedTips) GetOperationTime() int64 { - if m != nil { - return m.OperationTime +func (x *FriendAddedTips) GetOperationTime() int64 { + if x != nil { + return x.OperationTime } return 0 } -func (m *FriendAddedTips) GetOpUser() *PublicUserInfo { - if m != nil { - return m.OpUser +func (x *FriendAddedTips) GetOpUser() *PublicUserInfo { + if x != nil { + return x.OpUser } return nil } // FromUserID deleted a friend ToUserID type FriendDeletedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` } -func (m *FriendDeletedTips) Reset() { *m = FriendDeletedTips{} } -func (m *FriendDeletedTips) String() string { return proto.CompactTextString(m) } -func (*FriendDeletedTips) ProtoMessage() {} +func (x *FriendDeletedTips) Reset() { + *x = FriendDeletedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendDeletedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendDeletedTips) ProtoMessage() {} + +func (x *FriendDeletedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[32] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendDeletedTips.ProtoReflect.Descriptor instead. func (*FriendDeletedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{32} -} -func (m *FriendDeletedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendDeletedTips.Unmarshal(m, b) -} -func (m *FriendDeletedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendDeletedTips.Marshal(b, m, deterministic) -} -func (dst *FriendDeletedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendDeletedTips.Merge(dst, src) -} -func (m *FriendDeletedTips) XXX_Size() int { - return xxx_messageInfo_FriendDeletedTips.Size(m) -} -func (m *FriendDeletedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendDeletedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{32} } -var xxx_messageInfo_FriendDeletedTips proto.InternalMessageInfo - -func (m *FriendDeletedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *FriendDeletedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } type BlackAddedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` } -func (m *BlackAddedTips) Reset() { *m = BlackAddedTips{} } -func (m *BlackAddedTips) String() string { return proto.CompactTextString(m) } -func (*BlackAddedTips) ProtoMessage() {} +func (x *BlackAddedTips) Reset() { + *x = BlackAddedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlackAddedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlackAddedTips) ProtoMessage() {} + +func (x *BlackAddedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[33] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlackAddedTips.ProtoReflect.Descriptor instead. func (*BlackAddedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{33} -} -func (m *BlackAddedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackAddedTips.Unmarshal(m, b) -} -func (m *BlackAddedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackAddedTips.Marshal(b, m, deterministic) -} -func (dst *BlackAddedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackAddedTips.Merge(dst, src) -} -func (m *BlackAddedTips) XXX_Size() int { - return xxx_messageInfo_BlackAddedTips.Size(m) -} -func (m *BlackAddedTips) XXX_DiscardUnknown() { - xxx_messageInfo_BlackAddedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{33} } -var xxx_messageInfo_BlackAddedTips proto.InternalMessageInfo - -func (m *BlackAddedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *BlackAddedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } type BlackDeletedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` } -func (m *BlackDeletedTips) Reset() { *m = BlackDeletedTips{} } -func (m *BlackDeletedTips) String() string { return proto.CompactTextString(m) } -func (*BlackDeletedTips) ProtoMessage() {} +func (x *BlackDeletedTips) Reset() { + *x = BlackDeletedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlackDeletedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlackDeletedTips) ProtoMessage() {} + +func (x *BlackDeletedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlackDeletedTips.ProtoReflect.Descriptor instead. func (*BlackDeletedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{34} -} -func (m *BlackDeletedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_BlackDeletedTips.Unmarshal(m, b) -} -func (m *BlackDeletedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_BlackDeletedTips.Marshal(b, m, deterministic) -} -func (dst *BlackDeletedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_BlackDeletedTips.Merge(dst, src) -} -func (m *BlackDeletedTips) XXX_Size() int { - return xxx_messageInfo_BlackDeletedTips.Size(m) -} -func (m *BlackDeletedTips) XXX_DiscardUnknown() { - xxx_messageInfo_BlackDeletedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{34} } -var xxx_messageInfo_BlackDeletedTips proto.InternalMessageInfo - -func (m *BlackDeletedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *BlackDeletedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } type FriendInfoChangedTips struct { - FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID" json:"fromToUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromToUserID *FromToUserID `protobuf:"bytes,1,opt,name=fromToUserID,proto3" json:"fromToUserID,omitempty"` } -func (m *FriendInfoChangedTips) Reset() { *m = FriendInfoChangedTips{} } -func (m *FriendInfoChangedTips) String() string { return proto.CompactTextString(m) } -func (*FriendInfoChangedTips) ProtoMessage() {} +func (x *FriendInfoChangedTips) Reset() { + *x = FriendInfoChangedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FriendInfoChangedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FriendInfoChangedTips) ProtoMessage() {} + +func (x *FriendInfoChangedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[35] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FriendInfoChangedTips.ProtoReflect.Descriptor instead. func (*FriendInfoChangedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{35} -} -func (m *FriendInfoChangedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_FriendInfoChangedTips.Unmarshal(m, b) -} -func (m *FriendInfoChangedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_FriendInfoChangedTips.Marshal(b, m, deterministic) -} -func (dst *FriendInfoChangedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_FriendInfoChangedTips.Merge(dst, src) -} -func (m *FriendInfoChangedTips) XXX_Size() int { - return xxx_messageInfo_FriendInfoChangedTips.Size(m) -} -func (m *FriendInfoChangedTips) XXX_DiscardUnknown() { - xxx_messageInfo_FriendInfoChangedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{35} } -var xxx_messageInfo_FriendInfoChangedTips proto.InternalMessageInfo - -func (m *FriendInfoChangedTips) GetFromToUserID() *FromToUserID { - if m != nil { - return m.FromToUserID +func (x *FriendInfoChangedTips) GetFromToUserID() *FromToUserID { + if x != nil { + return x.FromToUserID } return nil } -// ////////////////////user///////////////////// +//////////////////////user///////////////////// type UserInfoUpdatedTips struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` } -func (m *UserInfoUpdatedTips) Reset() { *m = UserInfoUpdatedTips{} } -func (m *UserInfoUpdatedTips) String() string { return proto.CompactTextString(m) } -func (*UserInfoUpdatedTips) ProtoMessage() {} +func (x *UserInfoUpdatedTips) Reset() { + *x = UserInfoUpdatedTips{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserInfoUpdatedTips) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserInfoUpdatedTips) ProtoMessage() {} + +func (x *UserInfoUpdatedTips) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[36] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserInfoUpdatedTips.ProtoReflect.Descriptor instead. func (*UserInfoUpdatedTips) Descriptor() ([]byte, []int) { - return fileDescriptor_ws_c0d333d3b0a04e48, []int{36} -} -func (m *UserInfoUpdatedTips) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UserInfoUpdatedTips.Unmarshal(m, b) -} -func (m *UserInfoUpdatedTips) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UserInfoUpdatedTips.Marshal(b, m, deterministic) -} -func (dst *UserInfoUpdatedTips) XXX_Merge(src proto.Message) { - xxx_messageInfo_UserInfoUpdatedTips.Merge(dst, src) -} -func (m *UserInfoUpdatedTips) XXX_Size() int { - return xxx_messageInfo_UserInfoUpdatedTips.Size(m) -} -func (m *UserInfoUpdatedTips) XXX_DiscardUnknown() { - xxx_messageInfo_UserInfoUpdatedTips.DiscardUnknown(m) + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{36} } -var xxx_messageInfo_UserInfoUpdatedTips proto.InternalMessageInfo - -func (m *UserInfoUpdatedTips) GetUserID() string { - if m != nil { - return m.UserID +func (x *UserInfoUpdatedTips) GetUserID() string { + if x != nil { + return x.UserID } return "" } -func init() { - proto.RegisterType((*GroupInfo)(nil), "server_api_params.GroupInfo") - proto.RegisterType((*GroupMemberFullInfo)(nil), "server_api_params.GroupMemberFullInfo") - proto.RegisterType((*PublicUserInfo)(nil), "server_api_params.PublicUserInfo") - proto.RegisterType((*UserInfo)(nil), "server_api_params.UserInfo") - proto.RegisterType((*FriendInfo)(nil), "server_api_params.FriendInfo") - proto.RegisterType((*BlackInfo)(nil), "server_api_params.BlackInfo") - proto.RegisterType((*GroupRequest)(nil), "server_api_params.GroupRequest") - proto.RegisterType((*FriendRequest)(nil), "server_api_params.FriendRequest") - proto.RegisterType((*PullMessageBySeqListResp)(nil), "server_api_params.PullMessageBySeqListResp") - proto.RegisterType((*PullMessageBySeqListReq)(nil), "server_api_params.PullMessageBySeqListReq") - proto.RegisterType((*GetMaxAndMinSeqReq)(nil), "server_api_params.GetMaxAndMinSeqReq") - proto.RegisterType((*GetMaxAndMinSeqResp)(nil), "server_api_params.GetMaxAndMinSeqResp") - proto.RegisterType((*UserSendMsgResp)(nil), "server_api_params.UserSendMsgResp") - proto.RegisterType((*MsgData)(nil), "server_api_params.MsgData") - proto.RegisterMapType((map[string]bool)(nil), "server_api_params.MsgData.OptionsEntry") - proto.RegisterType((*OfflinePushInfo)(nil), "server_api_params.OfflinePushInfo") - proto.RegisterType((*TipsComm)(nil), "server_api_params.TipsComm") - proto.RegisterType((*GroupCreatedTips)(nil), "server_api_params.GroupCreatedTips") - proto.RegisterType((*GroupInfoSetTips)(nil), "server_api_params.GroupInfoSetTips") - proto.RegisterType((*JoinGroupApplicationTips)(nil), "server_api_params.JoinGroupApplicationTips") - proto.RegisterType((*MemberQuitTips)(nil), "server_api_params.MemberQuitTips") - proto.RegisterType((*GroupApplicationAcceptedTips)(nil), "server_api_params.GroupApplicationAcceptedTips") - proto.RegisterType((*GroupApplicationRejectedTips)(nil), "server_api_params.GroupApplicationRejectedTips") - proto.RegisterType((*GroupOwnerTransferredTips)(nil), "server_api_params.GroupOwnerTransferredTips") - proto.RegisterType((*MemberKickedTips)(nil), "server_api_params.MemberKickedTips") - proto.RegisterType((*MemberInvitedTips)(nil), "server_api_params.MemberInvitedTips") - proto.RegisterType((*MemberEnterTips)(nil), "server_api_params.MemberEnterTips") - proto.RegisterType((*FriendApplication)(nil), "server_api_params.FriendApplication") - proto.RegisterType((*FromToUserID)(nil), "server_api_params.FromToUserID") - proto.RegisterType((*FriendApplicationTips)(nil), "server_api_params.FriendApplicationTips") - proto.RegisterType((*FriendApplicationApprovedTips)(nil), "server_api_params.FriendApplicationApprovedTips") - proto.RegisterType((*FriendApplicationRejectedTips)(nil), "server_api_params.FriendApplicationRejectedTips") - proto.RegisterType((*FriendAddedTips)(nil), "server_api_params.FriendAddedTips") - proto.RegisterType((*FriendDeletedTips)(nil), "server_api_params.FriendDeletedTips") - proto.RegisterType((*BlackAddedTips)(nil), "server_api_params.BlackAddedTips") - proto.RegisterType((*BlackDeletedTips)(nil), "server_api_params.BlackDeletedTips") - proto.RegisterType((*FriendInfoChangedTips)(nil), "server_api_params.FriendInfoChangedTips") - proto.RegisterType((*UserInfoUpdatedTips)(nil), "server_api_params.UserInfoUpdatedTips") +///cms +type RequestPagination struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PageNumber int32 `protobuf:"varint,1,opt,name=pageNumber,proto3" json:"pageNumber,omitempty"` + ShowNumber int32 `protobuf:"varint,2,opt,name=showNumber,proto3" json:"showNumber,omitempty"` } -func init() { proto.RegisterFile("sdk_ws/ws.proto", fileDescriptor_ws_c0d333d3b0a04e48) } - -var fileDescriptor_ws_c0d333d3b0a04e48 = []byte{ - // 1903 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4f, 0x6f, 0x23, 0x49, - 0x15, 0x57, 0xdb, 0xb1, 0x63, 0x3f, 0xc7, 0x71, 0xa6, 0x67, 0x19, 0xcc, 0x30, 0x3b, 0x84, 0xd6, - 0x6a, 0x19, 0x21, 0x11, 0xa4, 0x41, 0x48, 0x30, 0x08, 0x50, 0x26, 0x99, 0x84, 0x59, 0xe2, 0x24, - 0xb4, 0x33, 0x5a, 0x0e, 0x48, 0xa3, 0x8e, 0xbb, 0xec, 0xf4, 0xa6, 0x5d, 0xd5, 0xae, 0xea, 0xce, - 0xcc, 0x48, 0x9c, 0xe0, 0x33, 0xc0, 0x07, 0xe0, 0x82, 0xb8, 0x20, 0x2e, 0x88, 0x0b, 0x47, 0xbe, - 0x00, 0x67, 0xbe, 0x02, 0x57, 0x0e, 0x48, 0x48, 0xa0, 0x7a, 0x55, 0xdd, 0x5d, 0xd5, 0xed, 0x64, - 0xad, 0x28, 0xda, 0xe1, 0xe6, 0xf7, 0xeb, 0x7a, 0x7f, 0xea, 0xfd, 0xab, 0x57, 0x65, 0x18, 0x88, - 0xf0, 0xf2, 0xf5, 0x1b, 0xf1, 0xed, 0x37, 0x62, 0x27, 0xe1, 0x2c, 0x65, 0xee, 0x3d, 0x41, 0xf8, - 0x15, 0xe1, 0xaf, 0x83, 0x24, 0x7a, 0x9d, 0x04, 0x3c, 0x98, 0x0b, 0xef, 0x5f, 0x0d, 0xe8, 0x1e, - 0x72, 0x96, 0x25, 0x2f, 0xe9, 0x94, 0xb9, 0x43, 0x58, 0x9f, 0x21, 0xb1, 0x3f, 0x74, 0xb6, 0x9d, - 0x27, 0x5d, 0x3f, 0x27, 0xdd, 0x47, 0xd0, 0xc5, 0x9f, 0xc7, 0xc1, 0x9c, 0x0c, 0x1b, 0xf8, 0xad, - 0x04, 0x5c, 0x0f, 0x36, 0x28, 0x4b, 0xa3, 0x69, 0x34, 0x09, 0xd2, 0x88, 0xd1, 0x61, 0x13, 0x17, - 0x58, 0x98, 0x5c, 0x13, 0xd1, 0x94, 0xb3, 0x30, 0x9b, 0xe0, 0x9a, 0x35, 0xb5, 0xc6, 0xc4, 0xa4, - 0xfe, 0x69, 0x30, 0x21, 0xaf, 0xfc, 0xa3, 0x61, 0x4b, 0xe9, 0xd7, 0xa4, 0xbb, 0x0d, 0x3d, 0xf6, - 0x86, 0x12, 0xfe, 0x4a, 0x10, 0xfe, 0x72, 0x7f, 0xd8, 0xc6, 0xaf, 0x26, 0xe4, 0x3e, 0x06, 0x98, - 0x70, 0x12, 0xa4, 0xe4, 0x2c, 0x9a, 0x93, 0xe1, 0xfa, 0xb6, 0xf3, 0xa4, 0xef, 0x1b, 0x88, 0x94, - 0x30, 0x27, 0xf3, 0x73, 0xc2, 0xf7, 0x58, 0x46, 0xd3, 0x61, 0x07, 0x17, 0x98, 0x90, 0xbb, 0x09, - 0x0d, 0xf2, 0x76, 0xd8, 0x45, 0xd1, 0x0d, 0xf2, 0xd6, 0x7d, 0x00, 0x6d, 0x91, 0x06, 0x69, 0x26, - 0x86, 0xb0, 0xed, 0x3c, 0x69, 0xf9, 0x9a, 0x72, 0x3f, 0x82, 0x3e, 0xca, 0x65, 0xb9, 0x35, 0x3d, - 0x64, 0xb1, 0xc1, 0xc2, 0x63, 0x67, 0xef, 0x12, 0x32, 0xdc, 0x40, 0x01, 0x25, 0xe0, 0xfd, 0xa5, - 0x01, 0xf7, 0xd1, 0xef, 0x23, 0x34, 0xe0, 0x20, 0x8b, 0xe3, 0xcf, 0x89, 0xc0, 0x03, 0x68, 0x67, - 0x4a, 0x9d, 0x72, 0xbf, 0xa6, 0xa4, 0x1e, 0xce, 0x62, 0x72, 0x44, 0xae, 0x48, 0x8c, 0x8e, 0x6f, - 0xf9, 0x25, 0xe0, 0x3e, 0x84, 0xce, 0x67, 0x2c, 0xa2, 0xe8, 0x13, 0xe9, 0xf1, 0xa6, 0x5f, 0xd0, - 0xf2, 0x1b, 0x8d, 0x26, 0x97, 0x54, 0x86, 0x54, 0xb9, 0xbb, 0xa0, 0xcd, 0x48, 0xb4, 0xed, 0x48, - 0x7c, 0x0c, 0x9b, 0x41, 0x92, 0x8c, 0x02, 0x3a, 0x23, 0x5c, 0x29, 0x5d, 0x47, 0xa5, 0x15, 0x54, - 0xc6, 0x43, 0x6a, 0x1a, 0xb3, 0x8c, 0x4f, 0x08, 0xba, 0xbb, 0xe5, 0x1b, 0x88, 0x94, 0xc3, 0x12, - 0xc2, 0x0d, 0x37, 0x2a, 0xcf, 0x57, 0x50, 0x1d, 0x15, 0xc8, 0xa3, 0xe2, 0x5d, 0xc1, 0xe6, 0x69, - 0x76, 0x1e, 0x47, 0x13, 0xfc, 0x2e, 0x7d, 0x56, 0x7a, 0xc6, 0xb1, 0x3c, 0x63, 0xee, 0xaf, 0x71, - 0xfd, 0xfe, 0x9a, 0xf6, 0xfe, 0x1e, 0x40, 0x7b, 0x46, 0x68, 0x48, 0x38, 0xfa, 0xab, 0xe5, 0x6b, - 0xca, 0xfb, 0x6d, 0x03, 0x3a, 0x5f, 0xac, 0x4a, 0x99, 0xb2, 0xc9, 0x05, 0xa3, 0xe4, 0x38, 0x93, - 0x39, 0xa2, 0x63, 0x64, 0x42, 0xee, 0x07, 0xd0, 0x3a, 0x8f, 0x78, 0x7a, 0x81, 0x41, 0xea, 0xfb, - 0x8a, 0x90, 0x28, 0x99, 0x07, 0x91, 0x8a, 0x4c, 0xd7, 0x57, 0x84, 0x76, 0x64, 0xa7, 0x48, 0x6f, - 0xbb, 0x60, 0xba, 0xb5, 0x82, 0xa9, 0x07, 0x1a, 0x96, 0x05, 0xda, 0xfb, 0xb7, 0x03, 0x70, 0xc0, - 0x23, 0x42, 0x43, 0x74, 0x4d, 0xa5, 0x52, 0x9d, 0x7a, 0xa5, 0x3e, 0x80, 0x36, 0x27, 0xf3, 0x80, - 0x5f, 0xe6, 0x99, 0xac, 0xa8, 0x8a, 0x41, 0xcd, 0x9a, 0x41, 0x3f, 0x00, 0x98, 0xa2, 0x1e, 0x29, - 0x07, 0x5d, 0xd5, 0x7b, 0xfa, 0xd5, 0x9d, 0x5a, 0x4f, 0xdb, 0xc9, 0xa3, 0xe4, 0x1b, 0xcb, 0x65, - 0x99, 0x04, 0x61, 0xa8, 0xb3, 0xb1, 0xa5, 0xca, 0xa4, 0x00, 0x96, 0x24, 0x63, 0xfb, 0x86, 0x64, - 0x5c, 0x2f, 0x92, 0xf1, 0x9f, 0x0e, 0x74, 0x9f, 0xc7, 0xc1, 0xe4, 0x72, 0xc5, 0xad, 0xdb, 0x5b, - 0x6c, 0xd4, 0xb6, 0x78, 0x08, 0xfd, 0x73, 0x29, 0x2e, 0xdf, 0x02, 0x7a, 0xa1, 0xf7, 0xf4, 0xeb, - 0x4b, 0x76, 0x69, 0x17, 0x81, 0x6f, 0xf3, 0xd9, 0xdb, 0x5d, 0xfb, 0xfc, 0xed, 0xb6, 0x6e, 0xd8, - 0x6e, 0xbb, 0xd8, 0xee, 0xdf, 0x1b, 0xb0, 0x81, 0x5d, 0xcb, 0x27, 0x8b, 0x8c, 0x88, 0xd4, 0xfd, - 0x21, 0x74, 0xb2, 0xdc, 0x54, 0x67, 0x55, 0x53, 0x0b, 0x16, 0xf7, 0x99, 0xee, 0x91, 0xc8, 0xdf, - 0x40, 0xfe, 0x47, 0x4b, 0xf8, 0x8b, 0x03, 0xca, 0x2f, 0x97, 0xcb, 0xf3, 0xe4, 0x22, 0xa0, 0x61, - 0x4c, 0x7c, 0x22, 0xb2, 0x38, 0xd5, 0xad, 0xcf, 0xc2, 0x54, 0xa6, 0x2d, 0x46, 0x62, 0xa6, 0x4f, - 0x1b, 0x4d, 0x49, 0xef, 0xa8, 0x75, 0xf2, 0x93, 0xda, 0x7a, 0x09, 0xc8, 0x42, 0xe5, 0x64, 0x81, - 0x11, 0x52, 0x65, 0x95, 0x93, 0xa5, 0x4e, 0xed, 0x35, 0x95, 0x08, 0x16, 0x26, 0x43, 0xac, 0x68, - 0x14, 0xa0, 0x8e, 0x19, 0x03, 0xa9, 0x9e, 0x32, 0xde, 0x3f, 0x9a, 0xd0, 0x57, 0xe5, 0x93, 0x3b, - 0xf5, 0xb1, 0xcc, 0x73, 0x36, 0xb7, 0xb2, 0xc8, 0x40, 0xa4, 0x15, 0x92, 0x3a, 0xb6, 0x1b, 0x8d, - 0x85, 0xc9, 0x54, 0x94, 0xf4, 0x81, 0xd5, 0x70, 0x4c, 0x28, 0xd7, 0x72, 0x68, 0x36, 0x1e, 0x03, - 0x91, 0xad, 0x2c, 0x65, 0x56, 0x76, 0x14, 0xb4, 0xe4, 0x4d, 0x59, 0xa1, 0x5f, 0xe5, 0x87, 0x81, - 0x48, 0xff, 0xa6, 0x2c, 0xd7, 0xad, 0x9c, 0x54, 0x02, 0x4a, 0xb2, 0xd6, 0xab, 0xce, 0x85, 0x82, - 0xae, 0x45, 0xb5, 0x7b, 0x63, 0x54, 0xc1, 0x8a, 0xaa, 0x5d, 0x5c, 0xbd, 0x5a, 0x71, 0x7d, 0x04, - 0x7d, 0x25, 0x27, 0x4f, 0xfa, 0x0d, 0x75, 0x6e, 0x5b, 0xa0, 0x9d, 0x1b, 0xfd, 0x6a, 0x6e, 0xd8, - 0xd1, 0xdd, 0xbc, 0x26, 0xba, 0x83, 0x22, 0xba, 0xbf, 0x84, 0xe1, 0x69, 0x16, 0xc7, 0x23, 0x22, - 0x44, 0x30, 0x23, 0xcf, 0xdf, 0x8d, 0xc9, 0xe2, 0x28, 0x12, 0xa9, 0x4f, 0x44, 0x22, 0xf3, 0x8c, - 0x70, 0xbe, 0xc7, 0x42, 0x82, 0x41, 0x6e, 0xf9, 0x39, 0x29, 0x77, 0x48, 0x38, 0x97, 0x06, 0xe8, - 0x0e, 0xa9, 0x28, 0x77, 0x07, 0xd6, 0xe2, 0x48, 0xc8, 0x5c, 0x6f, 0x3e, 0xe9, 0x3d, 0x7d, 0xb8, - 0xa4, 0x54, 0x46, 0x62, 0xb6, 0x1f, 0xa4, 0x81, 0x8f, 0xeb, 0xbc, 0x39, 0x7c, 0x79, 0xb9, 0xf6, - 0xc5, 0xb5, 0x27, 0x98, 0xec, 0x61, 0xd8, 0x04, 0x22, 0x46, 0x8b, 0x59, 0xc3, 0x84, 0xa4, 0xd9, - 0x42, 0xc9, 0x41, 0x3b, 0xfa, 0x7e, 0x4e, 0x7a, 0x1f, 0x80, 0x7b, 0x48, 0xd2, 0x51, 0xf0, 0x76, - 0x97, 0x86, 0xa3, 0x88, 0x8e, 0xc9, 0xc2, 0x27, 0x0b, 0xef, 0x05, 0xdc, 0xaf, 0xa1, 0x22, 0x91, - 0x06, 0xcc, 0x83, 0xb7, 0x63, 0xb2, 0x40, 0x03, 0xfa, 0xbe, 0xa6, 0x10, 0xc7, 0x55, 0xba, 0x3d, - 0x6a, 0xca, 0x5b, 0xc0, 0x40, 0x46, 0x68, 0x4c, 0x68, 0x38, 0x12, 0x33, 0x14, 0xb1, 0x0d, 0x3d, - 0xe5, 0x81, 0x91, 0x98, 0x95, 0xfd, 0xd6, 0x80, 0xe4, 0x8a, 0x49, 0x1c, 0x11, 0x9a, 0xaa, 0x15, - 0x7a, 0x37, 0x06, 0x24, 0x93, 0x51, 0x10, 0x1a, 0x16, 0x47, 0x4e, 0xd3, 0x2f, 0x68, 0xef, 0xaf, - 0x2d, 0x58, 0xd7, 0x0e, 0xc5, 0x61, 0x50, 0x1e, 0x71, 0x85, 0xbf, 0x14, 0xa5, 0x92, 0x71, 0x72, - 0x55, 0x8e, 0x65, 0x8a, 0x32, 0x07, 0xb9, 0xa6, 0x3d, 0xc8, 0x55, 0x6c, 0x5a, 0xab, 0xdb, 0x54, - 0xd9, 0x57, 0xab, 0xbe, 0xaf, 0x6f, 0xc2, 0x96, 0xc0, 0x82, 0x39, 0x8d, 0x83, 0x74, 0xca, 0xf8, - 0x5c, 0x9f, 0x58, 0x2d, 0xbf, 0x86, 0xcb, 0x66, 0xaf, 0xb0, 0xa2, 0x60, 0x55, 0x45, 0x56, 0x50, - 0x59, 0x1e, 0x0a, 0xc9, 0x0b, 0x57, 0x8d, 0x0a, 0x36, 0xa8, 0x6c, 0x13, 0x22, 0x62, 0x14, 0x07, - 0x5b, 0x55, 0x9f, 0x26, 0x24, 0x77, 0x3e, 0x17, 0xb3, 0x03, 0xce, 0xe6, 0x7a, 0x60, 0xc8, 0x49, - 0xdc, 0x39, 0xa3, 0x29, 0xa1, 0x29, 0xf2, 0xf6, 0x14, 0xaf, 0x01, 0x49, 0x5e, 0x4d, 0x62, 0x71, - 0x6e, 0xf8, 0x39, 0xe9, 0x6e, 0x41, 0x53, 0x90, 0x85, 0xae, 0x38, 0xf9, 0xd3, 0x8a, 0xdc, 0xc0, - 0x8e, 0x5c, 0xa5, 0x15, 0x6c, 0xe1, 0x57, 0xb3, 0x15, 0x94, 0xa3, 0xfd, 0x3d, 0x6b, 0xb4, 0xdf, - 0x85, 0x75, 0x96, 0xc8, 0x3c, 0x17, 0x43, 0x17, 0x6b, 0xec, 0x1b, 0xd7, 0xd7, 0xd8, 0xce, 0x89, - 0x5a, 0xf9, 0x82, 0xa6, 0xfc, 0x9d, 0x9f, 0xf3, 0xb9, 0x47, 0x30, 0x60, 0xd3, 0x69, 0x1c, 0x51, - 0x72, 0x9a, 0x89, 0x0b, 0x3c, 0xd9, 0xee, 0xe3, 0xc9, 0xe6, 0x2d, 0x11, 0x75, 0x62, 0xaf, 0xf4, - 0xab, 0xac, 0x0f, 0x9f, 0xc1, 0x86, 0xa9, 0x46, 0xba, 0xe1, 0x92, 0xbc, 0xd3, 0x39, 0x28, 0x7f, - 0xca, 0x61, 0xef, 0x2a, 0x88, 0x33, 0x75, 0x0c, 0x74, 0x7c, 0x45, 0x3c, 0x6b, 0x7c, 0xcf, 0xf1, - 0x7e, 0xe3, 0xc0, 0xa0, 0xa2, 0x40, 0xae, 0x4e, 0xa3, 0x34, 0x26, 0x5a, 0x82, 0x22, 0x5c, 0x17, - 0xd6, 0x42, 0x22, 0x26, 0x3a, 0x85, 0xf1, 0xb7, 0xee, 0x64, 0xcd, 0x62, 0x5c, 0x94, 0xf7, 0xb7, - 0x93, 0xb1, 0x14, 0x34, 0x66, 0x19, 0x0d, 0x8b, 0xfb, 0x9b, 0x81, 0xc9, 0x14, 0x8a, 0x4e, 0xc6, - 0xcf, 0x83, 0x70, 0x46, 0xd4, 0x2d, 0xab, 0x85, 0x36, 0xd9, 0xa0, 0x17, 0x42, 0xe7, 0x2c, 0x4a, - 0xc4, 0x1e, 0x9b, 0xcf, 0x65, 0x20, 0x42, 0x92, 0xca, 0x59, 0xd5, 0xc1, 0x78, 0x6b, 0x4a, 0xa6, - 0x4a, 0x48, 0xa6, 0x41, 0x16, 0xa7, 0x72, 0x69, 0x5e, 0xb8, 0x06, 0x84, 0xf7, 0x0b, 0xc1, 0xe8, - 0xbe, 0xe2, 0x56, 0x76, 0x1a, 0x88, 0xf7, 0xb7, 0x06, 0x6c, 0xe1, 0xe0, 0xb0, 0x87, 0x61, 0x0f, - 0x91, 0xe9, 0x29, 0xb4, 0xb0, 0x0c, 0xf5, 0xb0, 0x72, 0xf3, 0xb0, 0xa1, 0x96, 0xba, 0x3f, 0x82, - 0x36, 0x4b, 0x70, 0xe4, 0x54, 0x13, 0xca, 0xc7, 0xd7, 0x31, 0xd9, 0x57, 0x39, 0x5f, 0x73, 0xb9, - 0x07, 0x00, 0xea, 0x96, 0x79, 0x54, 0xb6, 0xee, 0x55, 0x65, 0x18, 0x9c, 0xd2, 0xb9, 0x45, 0x1b, - 0x36, 0xee, 0x73, 0x36, 0xe8, 0x1e, 0xc3, 0x26, 0x9a, 0x7d, 0x92, 0x4f, 0x9d, 0x18, 0x83, 0xd5, - 0x35, 0x56, 0xb8, 0xbd, 0xdf, 0x39, 0xda, 0x8d, 0xf2, 0xeb, 0x98, 0x28, 0xdf, 0x97, 0x2e, 0x71, - 0x6e, 0xe5, 0x92, 0x87, 0xd0, 0x99, 0x67, 0xc6, 0x10, 0xdc, 0xf4, 0x0b, 0xba, 0x0c, 0x51, 0x73, - 0xe5, 0x10, 0x79, 0xbf, 0x77, 0x60, 0xf8, 0x09, 0x8b, 0x28, 0x7e, 0xd8, 0x4d, 0x92, 0x58, 0x3f, - 0x3a, 0xdc, 0x3a, 0xe6, 0x3f, 0x86, 0x6e, 0xa0, 0xc4, 0xd0, 0x54, 0x87, 0x7d, 0x85, 0xc1, 0xb6, - 0xe4, 0x31, 0x66, 0x94, 0xa6, 0x39, 0xa3, 0x78, 0x7f, 0x74, 0x60, 0x53, 0x39, 0xe5, 0x67, 0x59, - 0x94, 0xde, 0xda, 0xbe, 0xe7, 0xd0, 0x59, 0x64, 0x51, 0x7a, 0x8b, 0xac, 0x2c, 0xf8, 0xea, 0xf9, - 0xd4, 0x5c, 0x92, 0x4f, 0xde, 0x9f, 0x1c, 0x78, 0x54, 0x75, 0xeb, 0xee, 0x64, 0x42, 0x92, 0xf7, - 0x59, 0x52, 0xd6, 0x8c, 0xb6, 0x56, 0x99, 0xd1, 0x96, 0x9a, 0xec, 0x93, 0xcf, 0xc8, 0xe4, 0xff, - 0xd7, 0xe4, 0x5f, 0x37, 0xe0, 0x2b, 0x87, 0x45, 0xe1, 0x9d, 0xf1, 0x80, 0x8a, 0x29, 0xe1, 0xfc, - 0x3d, 0xda, 0x7b, 0x04, 0x7d, 0x4a, 0xde, 0x94, 0x36, 0xe9, 0x72, 0x5c, 0x55, 0x8c, 0xcd, 0xbc, - 0x5a, 0xef, 0xf2, 0xfe, 0xe3, 0xc0, 0x96, 0x92, 0xf3, 0xd3, 0x68, 0x72, 0xf9, 0x1e, 0x37, 0x7f, - 0x0c, 0x9b, 0x97, 0x68, 0x81, 0xa4, 0x6e, 0xd1, 0xb6, 0x2b, 0xdc, 0x2b, 0x6e, 0xff, 0xbf, 0x0e, - 0xdc, 0x53, 0x82, 0x5e, 0xd2, 0xab, 0xe8, 0x7d, 0x26, 0xeb, 0x29, 0x0c, 0x22, 0x65, 0xc2, 0x2d, - 0x1d, 0x50, 0x65, 0x5f, 0xd1, 0x03, 0x7f, 0x76, 0x60, 0xa0, 0x24, 0xbd, 0xa0, 0x29, 0xe1, 0xb7, - 0xde, 0xff, 0x4f, 0xa0, 0x47, 0x68, 0xca, 0x03, 0x7a, 0x9b, 0x0e, 0x69, 0xb2, 0xae, 0xd8, 0x24, - 0x2f, 0xe1, 0x9e, 0xba, 0xc2, 0x1b, 0x1d, 0x47, 0xce, 0xb2, 0x41, 0xa8, 0xc6, 0x53, 0x07, 0x99, - 0x72, 0xd2, 0x7e, 0x9c, 0xd1, 0x8f, 0xe9, 0xe5, 0xe3, 0xcc, 0x63, 0x80, 0x20, 0x0c, 0x3f, 0x65, - 0x3c, 0x8c, 0x68, 0x7e, 0x7c, 0x18, 0x88, 0xf7, 0x09, 0x6c, 0xc8, 0x69, 0xfa, 0xcc, 0xb8, 0x8c, - 0xdf, 0xf8, 0x5c, 0x60, 0x5e, 0xe4, 0x1b, 0xf6, 0x45, 0xde, 0xfb, 0x05, 0x7c, 0xa9, 0x66, 0x38, - 0x7a, 0x7d, 0x4f, 0xbd, 0x31, 0xe4, 0x4a, 0xb4, 0xf3, 0xbf, 0xb6, 0xc4, 0x85, 0xa6, 0x2d, 0xbe, - 0xc5, 0xe4, 0xfd, 0xca, 0x81, 0x0f, 0x6b, 0xe2, 0x77, 0x93, 0x84, 0xb3, 0x2b, 0x9d, 0xdc, 0x77, - 0xa1, 0xc6, 0x6e, 0xad, 0x8d, 0x6a, 0x6b, 0x5d, 0x6a, 0x84, 0x75, 0x1c, 0x7c, 0x01, 0x46, 0xfc, - 0xc1, 0x81, 0x81, 0x36, 0x22, 0x0c, 0xb5, 0xda, 0xef, 0x42, 0x5b, 0xbd, 0x4f, 0x6a, 0x85, 0x1f, - 0x2e, 0x55, 0x98, 0xbf, 0xab, 0xfa, 0x7a, 0x71, 0x3d, 0x23, 0x1b, 0xcb, 0xc6, 0xc0, 0xef, 0x17, - 0x1d, 0x60, 0xe5, 0x17, 0x44, 0xcd, 0xe0, 0xfd, 0x3c, 0x4f, 0xe6, 0x7d, 0x12, 0x93, 0xbb, 0xf4, - 0x91, 0xf7, 0x0a, 0x36, 0xf1, 0xb1, 0xb4, 0xf4, 0xc1, 0x9d, 0x88, 0xfd, 0x14, 0xb6, 0x50, 0xec, - 0x9d, 0xdb, 0x5b, 0x54, 0x87, 0xf4, 0xcf, 0xde, 0x45, 0x40, 0x67, 0x77, 0x29, 0xfd, 0x5b, 0x70, - 0x3f, 0xf7, 0xfd, 0xab, 0x24, 0x2c, 0xae, 0x28, 0xd7, 0x3c, 0xcc, 0x9c, 0xb7, 0xf1, 0x3f, 0xbc, - 0xef, 0xfc, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xbe, 0xeb, 0x20, 0x25, 0xd6, 0x1b, 0x00, 0x00, +func (x *RequestPagination) Reset() { + *x = RequestPagination{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *RequestPagination) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RequestPagination) ProtoMessage() {} + +func (x *RequestPagination) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[37] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RequestPagination.ProtoReflect.Descriptor instead. +func (*RequestPagination) Descriptor() ([]byte, []int) { + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{37} +} + +func (x *RequestPagination) GetPageNumber() int32 { + if x != nil { + return x.PageNumber + } + return 0 +} + +func (x *RequestPagination) GetShowNumber() int32 { + if x != nil { + return x.ShowNumber + } + return 0 +} + +type ResponsePagination struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CurrentPage int32 `protobuf:"varint,5,opt,name=CurrentPage,proto3" json:"CurrentPage,omitempty"` + ShowNumber int32 `protobuf:"varint,6,opt,name=ShowNumber,proto3" json:"ShowNumber,omitempty"` +} + +func (x *ResponsePagination) Reset() { + *x = ResponsePagination{} + if protoimpl.UnsafeEnabled { + mi := &file_sdk_ws_ws_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ResponsePagination) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResponsePagination) ProtoMessage() {} + +func (x *ResponsePagination) ProtoReflect() protoreflect.Message { + mi := &file_sdk_ws_ws_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResponsePagination.ProtoReflect.Descriptor instead. +func (*ResponsePagination) Descriptor() ([]byte, []int) { + return file_sdk_ws_ws_proto_rawDescGZIP(), []int{38} +} + +func (x *ResponsePagination) GetCurrentPage() int32 { + if x != nil { + return x.CurrentPage + } + return 0 +} + +func (x *ResponsePagination) GetShowNumber() int32 { + if x != nil { + return x.ShowNumber + } + return 0 +} + +var File_sdk_ws_ws_proto protoreflect.FileDescriptor + +var file_sdk_ws_ws_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x73, 0x64, 0x6b, 0x5f, 0x77, 0x73, 0x2f, 0x77, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x11, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x22, 0xf5, 0x02, 0x0a, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x6e, 0x6f, + 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x22, + 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x6e, 0x74, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x20, 0x0a, 0x0b, + 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1e, + 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x20, + 0x0a, 0x0b, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x65, 0x78, + 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, + 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1c, + 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x54, 0x79, 0x70, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x54, 0x79, 0x70, 0x65, 0x22, 0xb7, 0x02, 0x0a, + 0x13, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x12, 0x16, + 0x0a, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x4c, 0x65, + 0x76, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x72, 0x6f, 0x6c, 0x65, 0x4c, + 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1a, 0x0a, 0x08, 0x6a, 0x6f, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6a, 0x6f, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, + 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x26, 0x0a, 0x0e, 0x61, 0x70, 0x70, 0x4d, 0x61, 0x6e, + 0x67, 0x65, 0x72, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, + 0x61, 0x70, 0x70, 0x4d, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1e, + 0x0a, 0x0a, 0x6a, 0x6f, 0x69, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0a, 0x6a, 0x6f, 0x69, 0x6e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x26, + 0x0a, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x0a, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x02, 0x65, 0x78, 0x22, 0x76, 0x0a, 0x0e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x73, 0x65, 0x72, + 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, + 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x66, + 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x16, 0x0a, 0x06, 0x67, 0x65, 0x6e, 0x64, 0x65, 0x72, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x67, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x22, 0x96, + 0x02, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x75, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x66, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x16, 0x0a, 0x06, 0x67, 0x65, 0x6e, + 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x67, 0x65, 0x6e, 0x64, 0x65, + 0x72, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x69, 0x72, 0x74, 0x68, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x05, 0x62, 0x69, 0x72, 0x74, 0x68, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, + 0x69, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, + 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x65, 0x78, 0x12, + 0x1e, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, + 0x26, 0x0a, 0x0e, 0x61, 0x70, 0x70, 0x4d, 0x61, 0x6e, 0x67, 0x65, 0x72, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0e, 0x61, 0x70, 0x70, 0x4d, 0x61, 0x6e, 0x67, + 0x65, 0x72, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x22, 0xf9, 0x01, 0x0a, 0x0a, 0x46, 0x72, 0x69, 0x65, + 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x77, 0x6e, + 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x6d, 0x61, + 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x6d, 0x61, 0x72, 0x6b, + 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x3b, 0x0a, 0x0a, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x55, 0x73, 0x65, 0x72, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, + 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0a, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x0a, + 0x09, 0x61, 0x64, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x09, 0x61, 0x64, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x02, 0x65, 0x78, 0x22, 0xec, 0x01, 0x0a, 0x09, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x77, 0x6e, 0x65, 0x72, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x47, 0x0a, 0x0d, 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x50, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x62, + 0x6c, 0x61, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1c, 0x0a, 0x09, + 0x61, 0x64, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x09, 0x61, 0x64, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0e, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x44, 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, + 0x65, 0x78, 0x22, 0xd1, 0x02, 0x0a, 0x0c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x3d, 0x0a, 0x08, 0x75, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x75, 0x73, 0x65, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x3a, 0x0a, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, + 0x0a, 0x0c, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x71, 0x4d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x71, 0x4d, 0x73, 0x67, 0x12, 0x1c, 0x0a, 0x09, 0x68, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x54, + 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x72, 0x65, 0x71, 0x54, 0x69, + 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x44, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x54, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x68, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x02, 0x65, 0x78, 0x22, 0xdb, 0x03, 0x0a, 0x0d, 0x46, 0x72, 0x69, 0x65, 0x6e, + 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x72, 0x6f, 0x6d, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x72, + 0x6f, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x66, 0x72, 0x6f, 0x6d, + 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x66, 0x72, 0x6f, 0x6d, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, + 0x66, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x66, 0x72, 0x6f, 0x6d, 0x46, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x1e, + 0x0a, 0x0a, 0x66, 0x72, 0x6f, 0x6d, 0x47, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0a, 0x66, 0x72, 0x6f, 0x6d, 0x47, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x12, 0x1a, + 0x0a, 0x08, 0x74, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x74, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x74, 0x6f, + 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x74, 0x6f, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x6f, + 0x46, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, + 0x6f, 0x46, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x1a, 0x0a, 0x08, 0x74, 0x6f, 0x47, 0x65, + 0x6e, 0x64, 0x65, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x74, 0x6f, 0x47, 0x65, + 0x6e, 0x64, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x68, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x71, 0x4d, + 0x73, 0x67, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x71, 0x4d, 0x73, 0x67, + 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x0b, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, + 0x12, 0x24, 0x0a, 0x0d, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x4d, 0x73, 0x67, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, + 0x65, 0x4d, 0x73, 0x67, 0x12, 0x1e, 0x0a, 0x0a, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x54, 0x69, + 0x6d, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x54, 0x69, 0x6d, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x65, 0x78, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x65, 0x78, 0x22, 0x7c, 0x0a, 0x18, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x42, 0x79, 0x53, 0x65, 0x71, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, + 0x12, 0x18, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x72, + 0x72, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, + 0x73, 0x67, 0x12, 0x2e, 0x0a, 0x04, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x61, 0x74, 0x61, 0x52, 0x04, 0x6c, 0x69, + 0x73, 0x74, 0x22, 0x6d, 0x0a, 0x17, 0x50, 0x75, 0x6c, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x42, 0x79, 0x53, 0x65, 0x71, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, + 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x65, 0x71, 0x4c, 0x69, + 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0d, 0x52, 0x07, 0x73, 0x65, 0x71, 0x4c, 0x69, 0x73, + 0x74, 0x22, 0x14, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4d, 0x61, 0x78, 0x41, 0x6e, 0x64, 0x4d, 0x69, + 0x6e, 0x53, 0x65, 0x71, 0x52, 0x65, 0x71, 0x22, 0x45, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4d, 0x61, + 0x78, 0x41, 0x6e, 0x64, 0x4d, 0x69, 0x6e, 0x53, 0x65, 0x71, 0x52, 0x65, 0x73, 0x70, 0x12, 0x16, + 0x0a, 0x06, 0x6d, 0x61, 0x78, 0x53, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, + 0x6d, 0x61, 0x78, 0x53, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x69, 0x6e, 0x53, 0x65, 0x71, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6d, 0x69, 0x6e, 0x53, 0x65, 0x71, 0x22, 0x71, + 0x0a, 0x0f, 0x55, 0x73, 0x65, 0x72, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x73, 0x67, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x20, 0x0a, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4d, 0x73, 0x67, 0x49, 0x44, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4d, 0x73, + 0x67, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x4d, 0x73, 0x67, + 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x4d, 0x73, 0x67, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x22, 0xbc, 0x05, 0x0a, 0x07, 0x4d, 0x73, 0x67, 0x44, 0x61, 0x74, 0x61, 0x12, 0x16, 0x0a, + 0x06, 0x73, 0x65, 0x6e, 0x64, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, + 0x65, 0x6e, 0x64, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x63, 0x76, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x63, 0x76, 0x49, 0x44, 0x12, 0x18, 0x0a, + 0x07, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6c, 0x69, 0x65, 0x6e, + 0x74, 0x4d, 0x73, 0x67, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x6c, + 0x69, 0x65, 0x6e, 0x74, 0x4d, 0x73, 0x67, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x4d, 0x73, 0x67, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x4d, 0x73, 0x67, 0x49, 0x44, 0x12, 0x2a, 0x0a, 0x10, 0x73, + 0x65, 0x6e, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x49, 0x44, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x50, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x49, 0x44, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x65, 0x6e, 0x64, 0x65, + 0x72, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0e, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x24, 0x0a, 0x0d, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x46, 0x61, 0x63, 0x65, 0x55, 0x52, 0x4c, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x46, 0x61, + 0x63, 0x65, 0x55, 0x52, 0x4c, 0x12, 0x20, 0x0a, 0x0b, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, + 0x54, 0x79, 0x70, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x73, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x73, 0x67, 0x46, 0x72, + 0x6f, 0x6d, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x6d, 0x73, 0x67, 0x46, 0x72, 0x6f, + 0x6d, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, + 0x03, 0x73, 0x65, 0x71, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x73, 0x65, 0x71, 0x12, + 0x1a, 0x0a, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x08, 0x73, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x41, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x12, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, + 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x4d, 0x73, 0x67, 0x44, 0x61, 0x74, 0x61, + 0x2e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x6f, + 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4c, 0x0a, 0x0f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, + 0x65, 0x50, 0x75, 0x73, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x2e, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x50, 0x75, 0x73, 0x68, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x50, 0x75, 0x73, 0x68, + 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x3a, 0x0a, 0x0c, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, + 0x22, 0x95, 0x01, 0x0a, 0x0f, 0x4f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x50, 0x75, 0x73, 0x68, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x65, + 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x65, 0x73, 0x63, 0x12, 0x0e, + 0x0a, 0x02, 0x65, 0x78, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x65, 0x78, 0x12, 0x22, + 0x0a, 0x0c, 0x69, 0x4f, 0x53, 0x50, 0x75, 0x73, 0x68, 0x53, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x69, 0x4f, 0x53, 0x50, 0x75, 0x73, 0x68, 0x53, 0x6f, 0x75, + 0x6e, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x69, 0x4f, 0x53, 0x42, 0x61, 0x64, 0x67, 0x65, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x69, 0x4f, 0x53, 0x42, 0x61, + 0x64, 0x67, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x64, 0x0a, 0x08, 0x54, 0x69, 0x70, 0x73, + 0x43, 0x6f, 0x6d, 0x6d, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x20, 0x0a, 0x0b, + 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x69, 0x70, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x69, 0x70, 0x73, 0x12, 0x1e, + 0x0a, 0x0a, 0x6a, 0x73, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x6a, 0x73, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x22, 0xc4, + 0x02, 0x0a, 0x10, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x54, + 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x46, 0x0a, 0x0a, 0x6d, 0x65, 0x6d, 0x62, 0x65, + 0x72, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, + 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x4e, 0x0a, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, + 0x6e, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, + 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0e, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, + 0x72, 0x55, 0x73, 0x65, 0x72, 0x22, 0xa2, 0x01, 0x0a, 0x10, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x53, 0x65, 0x74, 0x54, 0x69, 0x70, 0x73, 0x12, 0x3e, 0x0a, 0x06, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x75, + 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6d, 0x75, + 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x22, 0xa7, 0x01, 0x0a, 0x18, 0x4a, + 0x6f, 0x69, 0x6e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, + 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3f, 0x0a, 0x09, 0x61, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x09, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x72, 0x65, 0x71, 0x4d, 0x73, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, + 0x71, 0x4d, 0x73, 0x67, 0x22, 0xae, 0x01, 0x0a, 0x0e, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x51, + 0x75, 0x69, 0x74, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, + 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x42, 0x0a, 0x08, 0x71, + 0x75, 0x69, 0x74, 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, + 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x71, 0x75, 0x69, 0x74, 0x55, 0x73, 0x65, 0x72, 0x12, + 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xb0, 0x01, 0x0a, 0x1c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x41, + 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, + 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, 0x06, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x68, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, + 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x22, 0xb0, 0x01, 0x0a, 0x1c, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6a, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, + 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, + 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1c, 0x0a, + 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x22, 0x83, 0x02, 0x0a, 0x19, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x72, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, + 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, + 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, + 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x4c, 0x0a, + 0x0d, 0x6e, 0x65, 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, + 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, + 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x6e, 0x65, + 0x77, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4f, 0x77, 0x6e, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, + 0x65, 0x22, 0xfc, 0x01, 0x0a, 0x10, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x4b, 0x69, 0x63, 0x6b, + 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, 0x06, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x4e, 0x0a, 0x0e, 0x6b, 0x69, + 0x63, 0x6b, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0e, 0x6b, 0x69, 0x63, 0x6b, + 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, + 0x22, 0xff, 0x01, 0x0a, 0x11, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x49, 0x6e, 0x76, 0x69, 0x74, + 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x3e, 0x0a, 0x06, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x12, 0x50, 0x0a, 0x0f, 0x69, 0x6e, + 0x76, 0x69, 0x74, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, + 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, + 0x62, 0x65, 0x72, 0x46, 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x69, 0x6e, 0x76, + 0x69, 0x74, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x24, 0x0a, 0x0d, + 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, + 0x6d, 0x65, 0x22, 0xb5, 0x01, 0x0a, 0x0f, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x45, 0x6e, 0x74, + 0x65, 0x72, 0x54, 0x69, 0x70, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x48, 0x0a, 0x0b, 0x65, 0x6e, + 0x74, 0x72, 0x61, 0x6e, 0x74, 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x26, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x46, + 0x75, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x65, 0x6e, 0x74, 0x72, 0x61, 0x6e, 0x74, + 0x55, 0x73, 0x65, 0x72, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x6b, 0x0a, 0x11, 0x46, 0x72, + 0x69, 0x65, 0x6e, 0x64, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x07, 0x61, 0x64, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x64, 0x64, + 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x61, 0x64, + 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x61, 0x64, 0x64, 0x57, 0x6f, + 0x72, 0x64, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x64, 0x64, + 0x57, 0x6f, 0x72, 0x64, 0x69, 0x6e, 0x67, 0x22, 0x4a, 0x0a, 0x0c, 0x46, 0x72, 0x6f, 0x6d, 0x54, + 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x66, 0x72, 0x6f, 0x6d, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x72, 0x6f, + 0x6d, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x74, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x74, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x22, 0x5c, 0x0a, 0x15, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x41, 0x70, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, + 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x22, 0x82, 0x01, 0x0a, 0x1d, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x41, 0x70, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x70, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x64, 0x54, + 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, + 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, + 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x68, 0x61, 0x6e, 0x64, + 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x68, 0x61, 0x6e, + 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x22, 0x82, 0x01, 0x0a, 0x1d, 0x46, 0x72, 0x69, 0x65, 0x6e, + 0x64, 0x41, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x6a, 0x65, + 0x63, 0x74, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x66, 0x72, 0x6f, 0x6d, + 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, + 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x1c, 0x0a, + 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x4d, 0x73, 0x67, 0x22, 0xa9, 0x01, 0x0a, 0x0f, + 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x41, 0x64, 0x64, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, + 0x35, 0x0a, 0x06, 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, + 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, + 0x66, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x12, 0x24, 0x0a, 0x0d, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x39, 0x0a, 0x06, + 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, + 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x06, 0x6f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x22, 0x58, 0x0a, 0x11, 0x46, 0x72, 0x69, 0x65, 0x6e, + 0x64, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, + 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x22, 0x55, 0x0a, 0x0e, 0x42, 0x6c, 0x61, 0x63, 0x6b, 0x41, 0x64, 0x64, 0x65, 0x64, 0x54, + 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, + 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, + 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x22, 0x57, 0x0a, 0x10, 0x42, 0x6c, 0x61, 0x63, + 0x6b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, + 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, + 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x22, 0x5c, 0x0a, 0x15, 0x46, 0x72, 0x69, 0x65, 0x6e, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x43, + 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x66, 0x72, + 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x46, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x6d, 0x54, 0x6f, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x22, + 0x2d, 0x0a, 0x13, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x54, 0x69, 0x70, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x22, 0x53, + 0x0a, 0x11, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x70, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x68, 0x6f, 0x77, 0x4e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x68, 0x6f, 0x77, 0x4e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x22, 0x56, 0x0a, 0x12, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x43, 0x75, 0x72, + 0x72, 0x65, 0x6e, 0x74, 0x50, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, + 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x50, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x53, + 0x68, 0x6f, 0x77, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0a, 0x53, 0x68, 0x6f, 0x77, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x42, 0x1c, 0x5a, 0x1a, 0x2e, + 0x2f, 0x73, 0x64, 0x6b, 0x5f, 0x77, 0x73, 0x3b, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, + 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x33, +} + +var ( + file_sdk_ws_ws_proto_rawDescOnce sync.Once + file_sdk_ws_ws_proto_rawDescData = file_sdk_ws_ws_proto_rawDesc +) + +func file_sdk_ws_ws_proto_rawDescGZIP() []byte { + file_sdk_ws_ws_proto_rawDescOnce.Do(func() { + file_sdk_ws_ws_proto_rawDescData = protoimpl.X.CompressGZIP(file_sdk_ws_ws_proto_rawDescData) + }) + return file_sdk_ws_ws_proto_rawDescData +} + +var file_sdk_ws_ws_proto_msgTypes = make([]protoimpl.MessageInfo, 40) +var file_sdk_ws_ws_proto_goTypes = []interface{}{ + (*GroupInfo)(nil), // 0: server_api_params.GroupInfo + (*GroupMemberFullInfo)(nil), // 1: server_api_params.GroupMemberFullInfo + (*PublicUserInfo)(nil), // 2: server_api_params.PublicUserInfo + (*UserInfo)(nil), // 3: server_api_params.UserInfo + (*FriendInfo)(nil), // 4: server_api_params.FriendInfo + (*BlackInfo)(nil), // 5: server_api_params.BlackInfo + (*GroupRequest)(nil), // 6: server_api_params.GroupRequest + (*FriendRequest)(nil), // 7: server_api_params.FriendRequest + (*PullMessageBySeqListResp)(nil), // 8: server_api_params.PullMessageBySeqListResp + (*PullMessageBySeqListReq)(nil), // 9: server_api_params.PullMessageBySeqListReq + (*GetMaxAndMinSeqReq)(nil), // 10: server_api_params.GetMaxAndMinSeqReq + (*GetMaxAndMinSeqResp)(nil), // 11: server_api_params.GetMaxAndMinSeqResp + (*UserSendMsgResp)(nil), // 12: server_api_params.UserSendMsgResp + (*MsgData)(nil), // 13: server_api_params.MsgData + (*OfflinePushInfo)(nil), // 14: server_api_params.OfflinePushInfo + (*TipsComm)(nil), // 15: server_api_params.TipsComm + (*GroupCreatedTips)(nil), // 16: server_api_params.GroupCreatedTips + (*GroupInfoSetTips)(nil), // 17: server_api_params.GroupInfoSetTips + (*JoinGroupApplicationTips)(nil), // 18: server_api_params.JoinGroupApplicationTips + (*MemberQuitTips)(nil), // 19: server_api_params.MemberQuitTips + (*GroupApplicationAcceptedTips)(nil), // 20: server_api_params.GroupApplicationAcceptedTips + (*GroupApplicationRejectedTips)(nil), // 21: server_api_params.GroupApplicationRejectedTips + (*GroupOwnerTransferredTips)(nil), // 22: server_api_params.GroupOwnerTransferredTips + (*MemberKickedTips)(nil), // 23: server_api_params.MemberKickedTips + (*MemberInvitedTips)(nil), // 24: server_api_params.MemberInvitedTips + (*MemberEnterTips)(nil), // 25: server_api_params.MemberEnterTips + (*FriendApplication)(nil), // 26: server_api_params.FriendApplication + (*FromToUserID)(nil), // 27: server_api_params.FromToUserID + (*FriendApplicationTips)(nil), // 28: server_api_params.FriendApplicationTips + (*FriendApplicationApprovedTips)(nil), // 29: server_api_params.FriendApplicationApprovedTips + (*FriendApplicationRejectedTips)(nil), // 30: server_api_params.FriendApplicationRejectedTips + (*FriendAddedTips)(nil), // 31: server_api_params.FriendAddedTips + (*FriendDeletedTips)(nil), // 32: server_api_params.FriendDeletedTips + (*BlackAddedTips)(nil), // 33: server_api_params.BlackAddedTips + (*BlackDeletedTips)(nil), // 34: server_api_params.BlackDeletedTips + (*FriendInfoChangedTips)(nil), // 35: server_api_params.FriendInfoChangedTips + (*UserInfoUpdatedTips)(nil), // 36: server_api_params.UserInfoUpdatedTips + (*RequestPagination)(nil), // 37: server_api_params.RequestPagination + (*ResponsePagination)(nil), // 38: server_api_params.ResponsePagination + nil, // 39: server_api_params.MsgData.OptionsEntry +} +var file_sdk_ws_ws_proto_depIdxs = []int32{ + 3, // 0: server_api_params.FriendInfo.friendUser:type_name -> server_api_params.UserInfo + 2, // 1: server_api_params.BlackInfo.blackUserInfo:type_name -> server_api_params.PublicUserInfo + 2, // 2: server_api_params.GroupRequest.userInfo:type_name -> server_api_params.PublicUserInfo + 0, // 3: server_api_params.GroupRequest.groupInfo:type_name -> server_api_params.GroupInfo + 13, // 4: server_api_params.PullMessageBySeqListResp.list:type_name -> server_api_params.MsgData + 39, // 5: server_api_params.MsgData.options:type_name -> server_api_params.MsgData.OptionsEntry + 14, // 6: server_api_params.MsgData.offlinePushInfo:type_name -> server_api_params.OfflinePushInfo + 0, // 7: server_api_params.GroupCreatedTips.group:type_name -> server_api_params.GroupInfo + 1, // 8: server_api_params.GroupCreatedTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 1, // 9: server_api_params.GroupCreatedTips.memberList:type_name -> server_api_params.GroupMemberFullInfo + 1, // 10: server_api_params.GroupCreatedTips.groupOwnerUser:type_name -> server_api_params.GroupMemberFullInfo + 1, // 11: server_api_params.GroupInfoSetTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 0, // 12: server_api_params.GroupInfoSetTips.group:type_name -> server_api_params.GroupInfo + 0, // 13: server_api_params.JoinGroupApplicationTips.group:type_name -> server_api_params.GroupInfo + 2, // 14: server_api_params.JoinGroupApplicationTips.applicant:type_name -> server_api_params.PublicUserInfo + 0, // 15: server_api_params.MemberQuitTips.group:type_name -> server_api_params.GroupInfo + 1, // 16: server_api_params.MemberQuitTips.quitUser:type_name -> server_api_params.GroupMemberFullInfo + 0, // 17: server_api_params.GroupApplicationAcceptedTips.group:type_name -> server_api_params.GroupInfo + 1, // 18: server_api_params.GroupApplicationAcceptedTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 0, // 19: server_api_params.GroupApplicationRejectedTips.group:type_name -> server_api_params.GroupInfo + 1, // 20: server_api_params.GroupApplicationRejectedTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 0, // 21: server_api_params.GroupOwnerTransferredTips.group:type_name -> server_api_params.GroupInfo + 1, // 22: server_api_params.GroupOwnerTransferredTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 1, // 23: server_api_params.GroupOwnerTransferredTips.newGroupOwner:type_name -> server_api_params.GroupMemberFullInfo + 0, // 24: server_api_params.MemberKickedTips.group:type_name -> server_api_params.GroupInfo + 1, // 25: server_api_params.MemberKickedTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 1, // 26: server_api_params.MemberKickedTips.kickedUserList:type_name -> server_api_params.GroupMemberFullInfo + 0, // 27: server_api_params.MemberInvitedTips.group:type_name -> server_api_params.GroupInfo + 1, // 28: server_api_params.MemberInvitedTips.opUser:type_name -> server_api_params.GroupMemberFullInfo + 1, // 29: server_api_params.MemberInvitedTips.invitedUserList:type_name -> server_api_params.GroupMemberFullInfo + 0, // 30: server_api_params.MemberEnterTips.group:type_name -> server_api_params.GroupInfo + 1, // 31: server_api_params.MemberEnterTips.entrantUser:type_name -> server_api_params.GroupMemberFullInfo + 27, // 32: server_api_params.FriendApplicationTips.fromToUserID:type_name -> server_api_params.FromToUserID + 27, // 33: server_api_params.FriendApplicationApprovedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 27, // 34: server_api_params.FriendApplicationRejectedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 4, // 35: server_api_params.FriendAddedTips.friend:type_name -> server_api_params.FriendInfo + 2, // 36: server_api_params.FriendAddedTips.opUser:type_name -> server_api_params.PublicUserInfo + 27, // 37: server_api_params.FriendDeletedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 27, // 38: server_api_params.BlackAddedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 27, // 39: server_api_params.BlackDeletedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 27, // 40: server_api_params.FriendInfoChangedTips.fromToUserID:type_name -> server_api_params.FromToUserID + 41, // [41:41] is the sub-list for method output_type + 41, // [41:41] is the sub-list for method input_type + 41, // [41:41] is the sub-list for extension type_name + 41, // [41:41] is the sub-list for extension extendee + 0, // [0:41] is the sub-list for field type_name +} + +func init() { file_sdk_ws_ws_proto_init() } +func file_sdk_ws_ws_proto_init() { + if File_sdk_ws_ws_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_sdk_ws_ws_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupMemberFullInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PublicUserInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlackInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PullMessageBySeqListResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PullMessageBySeqListReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMaxAndMinSeqReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMaxAndMinSeqResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserSendMsgResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MsgData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OfflinePushInfo); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TipsComm); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupCreatedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupInfoSetTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*JoinGroupApplicationTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MemberQuitTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupApplicationAcceptedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupApplicationRejectedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupOwnerTransferredTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MemberKickedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MemberInvitedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MemberEnterTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendApplication); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FromToUserID); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendApplicationTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendApplicationApprovedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendApplicationRejectedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendAddedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendDeletedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlackAddedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlackDeletedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FriendInfoChangedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserInfoUpdatedTips); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RequestPagination); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_sdk_ws_ws_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResponsePagination); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_sdk_ws_ws_proto_rawDesc, + NumEnums: 0, + NumMessages: 40, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_sdk_ws_ws_proto_goTypes, + DependencyIndexes: file_sdk_ws_ws_proto_depIdxs, + MessageInfos: file_sdk_ws_ws_proto_msgTypes, + }.Build() + File_sdk_ws_ws_proto = out.File + file_sdk_ws_ws_proto_rawDesc = nil + file_sdk_ws_ws_proto_goTypes = nil + file_sdk_ws_ws_proto_depIdxs = nil } diff --git a/pkg/proto/sdk_ws/ws.proto b/pkg/proto/sdk_ws/ws.proto index 77adabbc0..f86a5ea98 100644 --- a/pkg/proto/sdk_ws/ws.proto +++ b/pkg/proto/sdk_ws/ws.proto @@ -1,4 +1,5 @@ syntax = "proto3"; +option go_package = "./sdk_ws;server_api_params"; package server_api_params;//The package name to which the proto file belongs //option go_package = "./sdk_ws;open_im_sdk";//The generated go pb file is in the current directory, and the package name is open_im_sdk @@ -330,3 +331,14 @@ message FriendInfoChangedTips{ message UserInfoUpdatedTips{ string userID = 1; } + +///cms +message RequestPagination { + int32 pageNumber = 1; + int32 showNumber = 2; +} + +message ResponsePagination { + int32 CurrentPage = 5; + int32 ShowNumber = 6; +} \ No newline at end of file diff --git a/pkg/proto/statistics/statistics.pb.go b/pkg/proto/statistics/statistics.pb.go new file mode 100644 index 000000000..5fd528d97 --- /dev/null +++ b/pkg/proto/statistics/statistics.pb.go @@ -0,0 +1,1498 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.26.0 +// protoc v3.19.3 +// source: statistics/statistics.proto + +package statistics + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type StatisticsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + From string `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"` + To string `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"` +} + +func (x *StatisticsReq) Reset() { + *x = StatisticsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StatisticsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StatisticsReq) ProtoMessage() {} + +func (x *StatisticsReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StatisticsReq.ProtoReflect.Descriptor instead. +func (*StatisticsReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{0} +} + +func (x *StatisticsReq) GetFrom() string { + if x != nil { + return x.From + } + return "" +} + +func (x *StatisticsReq) GetTo() string { + if x != nil { + return x.To + } + return "" +} + +type GetActiveUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StatisticsReq *StatisticsReq `protobuf:"bytes,1,opt,name=StatisticsReq,proto3" json:"StatisticsReq,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetActiveUserReq) Reset() { + *x = GetActiveUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActiveUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActiveUserReq) ProtoMessage() {} + +func (x *GetActiveUserReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActiveUserReq.ProtoReflect.Descriptor instead. +func (*GetActiveUserReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{1} +} + +func (x *GetActiveUserReq) GetStatisticsReq() *StatisticsReq { + if x != nil { + return x.StatisticsReq + } + return nil +} + +func (x *GetActiveUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type UserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NickName string `protobuf:"bytes,1,opt,name=NickName,proto3" json:"NickName,omitempty"` + UserId string `protobuf:"bytes,2,opt,name=UserId,proto3" json:"UserId,omitempty"` + MessageNum int32 `protobuf:"varint,3,opt,name=MessageNum,proto3" json:"MessageNum,omitempty"` +} + +func (x *UserResp) Reset() { + *x = UserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UserResp) ProtoMessage() {} + +func (x *UserResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UserResp.ProtoReflect.Descriptor instead. +func (*UserResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{2} +} + +func (x *UserResp) GetNickName() string { + if x != nil { + return x.NickName + } + return "" +} + +func (x *UserResp) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *UserResp) GetMessageNum() int32 { + if x != nil { + return x.MessageNum + } + return 0 +} + +type GetActiveUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Users []*UserResp `protobuf:"bytes,1,rep,name=Users,proto3" json:"Users,omitempty"` +} + +func (x *GetActiveUserResp) Reset() { + *x = GetActiveUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActiveUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActiveUserResp) ProtoMessage() {} + +func (x *GetActiveUserResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActiveUserResp.ProtoReflect.Descriptor instead. +func (*GetActiveUserResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{3} +} + +func (x *GetActiveUserResp) GetUsers() []*UserResp { + if x != nil { + return x.Users + } + return nil +} + +type GetActiveGroupReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StatisticsReq *StatisticsReq `protobuf:"bytes,1,opt,name=StatisticsReq,proto3" json:"StatisticsReq,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetActiveGroupReq) Reset() { + *x = GetActiveGroupReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActiveGroupReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActiveGroupReq) ProtoMessage() {} + +func (x *GetActiveGroupReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActiveGroupReq.ProtoReflect.Descriptor instead. +func (*GetActiveGroupReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{4} +} + +func (x *GetActiveGroupReq) GetStatisticsReq() *StatisticsReq { + if x != nil { + return x.StatisticsReq + } + return nil +} + +func (x *GetActiveGroupReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GroupResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GroupName string `protobuf:"bytes,1,opt,name=GroupName,proto3" json:"GroupName,omitempty"` + GroupId string `protobuf:"bytes,2,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + MessageNum int32 `protobuf:"varint,3,opt,name=MessageNum,proto3" json:"MessageNum,omitempty"` +} + +func (x *GroupResp) Reset() { + *x = GroupResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GroupResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GroupResp) ProtoMessage() {} + +func (x *GroupResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GroupResp.ProtoReflect.Descriptor instead. +func (*GroupResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{5} +} + +func (x *GroupResp) GetGroupName() string { + if x != nil { + return x.GroupName + } + return "" +} + +func (x *GroupResp) GetGroupId() string { + if x != nil { + return x.GroupId + } + return "" +} + +func (x *GroupResp) GetMessageNum() int32 { + if x != nil { + return x.MessageNum + } + return 0 +} + +type GetActiveGroupResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Groups []*GroupResp `protobuf:"bytes,1,rep,name=Groups,proto3" json:"Groups,omitempty"` +} + +func (x *GetActiveGroupResp) Reset() { + *x = GetActiveGroupResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetActiveGroupResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetActiveGroupResp) ProtoMessage() {} + +func (x *GetActiveGroupResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetActiveGroupResp.ProtoReflect.Descriptor instead. +func (*GetActiveGroupResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{6} +} + +func (x *GetActiveGroupResp) GetGroups() []*GroupResp { + if x != nil { + return x.Groups + } + return nil +} + +type DateNumList struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Date string `protobuf:"bytes,1,opt,name=Date,proto3" json:"Date,omitempty"` + Num int32 `protobuf:"varint,2,opt,name=Num,proto3" json:"Num,omitempty"` +} + +func (x *DateNumList) Reset() { + *x = DateNumList{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DateNumList) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DateNumList) ProtoMessage() {} + +func (x *DateNumList) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DateNumList.ProtoReflect.Descriptor instead. +func (*DateNumList) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{7} +} + +func (x *DateNumList) GetDate() string { + if x != nil { + return x.Date + } + return "" +} + +func (x *DateNumList) GetNum() int32 { + if x != nil { + return x.Num + } + return 0 +} + +type GetMessageStatisticsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StatisticsReq *StatisticsReq `protobuf:"bytes,1,opt,name=StatisticsReq,proto3" json:"StatisticsReq,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetMessageStatisticsReq) Reset() { + *x = GetMessageStatisticsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetMessageStatisticsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMessageStatisticsReq) ProtoMessage() {} + +func (x *GetMessageStatisticsReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMessageStatisticsReq.ProtoReflect.Descriptor instead. +func (*GetMessageStatisticsReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{8} +} + +func (x *GetMessageStatisticsReq) GetStatisticsReq() *StatisticsReq { + if x != nil { + return x.StatisticsReq + } + return nil +} + +func (x *GetMessageStatisticsReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetMessageStatisticsResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PrivateMessageNum int32 `protobuf:"varint,1,opt,name=PrivateMessageNum,proto3" json:"PrivateMessageNum,omitempty"` + GroupMessageNum int32 `protobuf:"varint,2,opt,name=GroupMessageNum,proto3" json:"GroupMessageNum,omitempty"` + PrivateMessageNumList []*DateNumList `protobuf:"bytes,3,rep,name=PrivateMessageNumList,proto3" json:"PrivateMessageNumList,omitempty"` + GroupMessageNumList []*DateNumList `protobuf:"bytes,4,rep,name=GroupMessageNumList,proto3" json:"GroupMessageNumList,omitempty"` +} + +func (x *GetMessageStatisticsResp) Reset() { + *x = GetMessageStatisticsResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetMessageStatisticsResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetMessageStatisticsResp) ProtoMessage() {} + +func (x *GetMessageStatisticsResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetMessageStatisticsResp.ProtoReflect.Descriptor instead. +func (*GetMessageStatisticsResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{9} +} + +func (x *GetMessageStatisticsResp) GetPrivateMessageNum() int32 { + if x != nil { + return x.PrivateMessageNum + } + return 0 +} + +func (x *GetMessageStatisticsResp) GetGroupMessageNum() int32 { + if x != nil { + return x.GroupMessageNum + } + return 0 +} + +func (x *GetMessageStatisticsResp) GetPrivateMessageNumList() []*DateNumList { + if x != nil { + return x.PrivateMessageNumList + } + return nil +} + +func (x *GetMessageStatisticsResp) GetGroupMessageNumList() []*DateNumList { + if x != nil { + return x.GroupMessageNumList + } + return nil +} + +type GetGroupStatisticsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StatisticsReq *StatisticsReq `protobuf:"bytes,1,opt,name=StatisticsReq,proto3" json:"StatisticsReq,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetGroupStatisticsReq) Reset() { + *x = GetGroupStatisticsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupStatisticsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupStatisticsReq) ProtoMessage() {} + +func (x *GetGroupStatisticsReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupStatisticsReq.ProtoReflect.Descriptor instead. +func (*GetGroupStatisticsReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{10} +} + +func (x *GetGroupStatisticsReq) GetStatisticsReq() *StatisticsReq { + if x != nil { + return x.StatisticsReq + } + return nil +} + +func (x *GetGroupStatisticsReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetGroupStatisticsResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + IncreaseGroupNum int32 `protobuf:"varint,1,opt,name=IncreaseGroupNum,proto3" json:"IncreaseGroupNum,omitempty"` + TotalGroupNum int32 `protobuf:"varint,2,opt,name=TotalGroupNum,proto3" json:"TotalGroupNum,omitempty"` + IncreaseGroupNumList []*DateNumList `protobuf:"bytes,3,rep,name=IncreaseGroupNumList,proto3" json:"IncreaseGroupNumList,omitempty"` + TotalGroupNumList []*DateNumList `protobuf:"bytes,4,rep,name=TotalGroupNumList,proto3" json:"TotalGroupNumList,omitempty"` +} + +func (x *GetGroupStatisticsResp) Reset() { + *x = GetGroupStatisticsResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetGroupStatisticsResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetGroupStatisticsResp) ProtoMessage() {} + +func (x *GetGroupStatisticsResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetGroupStatisticsResp.ProtoReflect.Descriptor instead. +func (*GetGroupStatisticsResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{11} +} + +func (x *GetGroupStatisticsResp) GetIncreaseGroupNum() int32 { + if x != nil { + return x.IncreaseGroupNum + } + return 0 +} + +func (x *GetGroupStatisticsResp) GetTotalGroupNum() int32 { + if x != nil { + return x.TotalGroupNum + } + return 0 +} + +func (x *GetGroupStatisticsResp) GetIncreaseGroupNumList() []*DateNumList { + if x != nil { + return x.IncreaseGroupNumList + } + return nil +} + +func (x *GetGroupStatisticsResp) GetTotalGroupNumList() []*DateNumList { + if x != nil { + return x.TotalGroupNumList + } + return nil +} + +type GetUserStatisticsReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + StatisticsReq *StatisticsReq `protobuf:"bytes,1,opt,name=StatisticsReq,proto3" json:"StatisticsReq,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetUserStatisticsReq) Reset() { + *x = GetUserStatisticsReq{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserStatisticsReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserStatisticsReq) ProtoMessage() {} + +func (x *GetUserStatisticsReq) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserStatisticsReq.ProtoReflect.Descriptor instead. +func (*GetUserStatisticsReq) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{12} +} + +func (x *GetUserStatisticsReq) GetStatisticsReq() *StatisticsReq { + if x != nil { + return x.StatisticsReq + } + return nil +} + +func (x *GetUserStatisticsReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetUserStatisticsResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + IncreaseUserNum int32 `protobuf:"varint,1,opt,name=IncreaseUserNum,proto3" json:"IncreaseUserNum,omitempty"` + ActiveUserNum int32 `protobuf:"varint,2,opt,name=ActiveUserNum,proto3" json:"ActiveUserNum,omitempty"` + TotalUserNum int32 `protobuf:"varint,3,opt,name=TotalUserNum,proto3" json:"TotalUserNum,omitempty"` + IncreaseUserNumList []*DateNumList `protobuf:"bytes,4,rep,name=IncreaseUserNumList,proto3" json:"IncreaseUserNumList,omitempty"` + ActiveUserNumList []*DateNumList `protobuf:"bytes,5,rep,name=ActiveUserNumList,proto3" json:"ActiveUserNumList,omitempty"` + TotalUserNumList []*DateNumList `protobuf:"bytes,6,rep,name=TotalUserNumList,proto3" json:"TotalUserNumList,omitempty"` +} + +func (x *GetUserStatisticsResp) Reset() { + *x = GetUserStatisticsResp{} + if protoimpl.UnsafeEnabled { + mi := &file_statistics_statistics_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserStatisticsResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserStatisticsResp) ProtoMessage() {} + +func (x *GetUserStatisticsResp) ProtoReflect() protoreflect.Message { + mi := &file_statistics_statistics_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserStatisticsResp.ProtoReflect.Descriptor instead. +func (*GetUserStatisticsResp) Descriptor() ([]byte, []int) { + return file_statistics_statistics_proto_rawDescGZIP(), []int{13} +} + +func (x *GetUserStatisticsResp) GetIncreaseUserNum() int32 { + if x != nil { + return x.IncreaseUserNum + } + return 0 +} + +func (x *GetUserStatisticsResp) GetActiveUserNum() int32 { + if x != nil { + return x.ActiveUserNum + } + return 0 +} + +func (x *GetUserStatisticsResp) GetTotalUserNum() int32 { + if x != nil { + return x.TotalUserNum + } + return 0 +} + +func (x *GetUserStatisticsResp) GetIncreaseUserNumList() []*DateNumList { + if x != nil { + return x.IncreaseUserNumList + } + return nil +} + +func (x *GetUserStatisticsResp) GetActiveUserNumList() []*DateNumList { + if x != nil { + return x.ActiveUserNumList + } + return nil +} + +func (x *GetUserStatisticsResp) GetTotalUserNumList() []*DateNumList { + if x != nil { + return x.TotalUserNumList + } + return nil +} + +var File_statistics_statistics_proto protoreflect.FileDescriptor + +var file_statistics_statistics_proto_rawDesc = []byte{ + 0x0a, 0x1b, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2f, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0a, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x22, 0x33, 0x0a, 0x0d, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, + 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, + 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x74, 0x6f, 0x22, 0x75, + 0x0a, 0x10, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x65, 0x71, 0x12, 0x3f, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x74, 0x61, 0x74, + 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, + 0x73, 0x52, 0x65, 0x71, 0x52, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x5e, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, + 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x4e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x22, 0x3f, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2a, 0x0a, 0x05, 0x55, 0x73, + 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x74, 0x61, 0x74, + 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x52, + 0x05, 0x55, 0x73, 0x65, 0x72, 0x73, 0x22, 0x76, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, + 0x69, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x12, 0x3f, 0x0a, 0x0d, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x52, 0x0d, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x63, + 0x0a, 0x09, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x1c, 0x0a, 0x09, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x49, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x75, + 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x4e, 0x75, 0x6d, 0x22, 0x43, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2d, 0x0a, 0x06, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x74, 0x61, 0x74, + 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, + 0x52, 0x06, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x22, 0x33, 0x0a, 0x0b, 0x44, 0x61, 0x74, 0x65, + 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x44, 0x61, 0x74, 0x65, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x44, 0x61, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x4e, + 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x4e, 0x75, 0x6d, 0x22, 0x7c, 0x0a, + 0x17, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x12, 0x3f, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x19, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x52, 0x0d, 0x53, 0x74, 0x61, 0x74, + 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x8c, 0x02, 0x0a, 0x18, + 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2c, 0x0a, 0x11, 0x50, 0x72, 0x69, 0x76, + 0x61, 0x74, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x11, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x12, 0x28, 0x0a, 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x0f, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, + 0x12, 0x4d, 0x0a, 0x15, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, + 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x15, 0x50, 0x72, 0x69, 0x76, 0x61, 0x74, + 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x12, + 0x49, 0x0a, 0x13, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4e, + 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x4e, 0x75, + 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x13, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x7a, 0x0a, 0x15, 0x47, 0x65, + 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x71, 0x12, 0x3f, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, + 0x73, 0x52, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x74, 0x61, + 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, + 0x63, 0x73, 0x52, 0x65, 0x71, 0x52, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, + 0x73, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xfe, 0x01, 0x0a, 0x16, 0x47, 0x65, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x2a, 0x0a, 0x10, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x49, 0x6e, 0x63, + 0x72, 0x65, 0x61, 0x73, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x12, 0x24, 0x0a, + 0x0d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4e, 0x75, 0x6d, 0x12, 0x4b, 0x0a, 0x14, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, + 0x61, 0x74, 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x14, 0x49, 0x6e, 0x63, 0x72, + 0x65, 0x61, 0x73, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, + 0x12, 0x45, 0x0a, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4e, 0x75, + 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x4e, 0x75, 0x6d, + 0x4c, 0x69, 0x73, 0x74, 0x52, 0x11, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x79, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x55, 0x73, + 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x12, + 0x3f, 0x0a, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, + 0x71, 0x52, 0x0d, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, + 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x22, 0xe2, 0x02, 0x0a, 0x15, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x28, 0x0a, 0x0f, + 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x55, + 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x12, 0x24, 0x0a, 0x0d, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x41, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x12, 0x22, 0x0a, 0x0c, + 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x05, 0x52, 0x0c, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, + 0x12, 0x49, 0x0a, 0x13, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x4e, + 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x13, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x45, 0x0a, 0x11, 0x41, + 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x11, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x4c, 0x69, + 0x73, 0x74, 0x12, 0x43, 0x0a, 0x10, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x4e, + 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x4e, 0x75, + 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x10, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x55, 0x73, 0x65, 0x72, + 0x4e, 0x75, 0x6d, 0x4c, 0x69, 0x73, 0x74, 0x32, 0xbf, 0x03, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, + 0x12, 0x4c, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, + 0x72, 0x12, 0x1c, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, + 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, + 0x1d, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4f, + 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x1d, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, + 0x74, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x1a, + 0x1e, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, + 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x61, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, + 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x12, 0x23, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x24, 0x2e, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x5b, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x12, 0x21, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x22, 0x2e, 0x73, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x58, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x73, 0x12, 0x20, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, + 0x73, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x21, 0x2e, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, + 0x69, 0x63, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x42, 0x19, 0x5a, 0x17, 0x2e, 0x2f, 0x73, + 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x3b, 0x73, 0x74, 0x61, 0x74, 0x69, 0x73, + 0x74, 0x69, 0x63, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_statistics_statistics_proto_rawDescOnce sync.Once + file_statistics_statistics_proto_rawDescData = file_statistics_statistics_proto_rawDesc +) + +func file_statistics_statistics_proto_rawDescGZIP() []byte { + file_statistics_statistics_proto_rawDescOnce.Do(func() { + file_statistics_statistics_proto_rawDescData = protoimpl.X.CompressGZIP(file_statistics_statistics_proto_rawDescData) + }) + return file_statistics_statistics_proto_rawDescData +} + +var file_statistics_statistics_proto_msgTypes = make([]protoimpl.MessageInfo, 14) +var file_statistics_statistics_proto_goTypes = []interface{}{ + (*StatisticsReq)(nil), // 0: statistics.StatisticsReq + (*GetActiveUserReq)(nil), // 1: statistics.GetActiveUserReq + (*UserResp)(nil), // 2: statistics.UserResp + (*GetActiveUserResp)(nil), // 3: statistics.GetActiveUserResp + (*GetActiveGroupReq)(nil), // 4: statistics.GetActiveGroupReq + (*GroupResp)(nil), // 5: statistics.GroupResp + (*GetActiveGroupResp)(nil), // 6: statistics.GetActiveGroupResp + (*DateNumList)(nil), // 7: statistics.DateNumList + (*GetMessageStatisticsReq)(nil), // 8: statistics.GetMessageStatisticsReq + (*GetMessageStatisticsResp)(nil), // 9: statistics.GetMessageStatisticsResp + (*GetGroupStatisticsReq)(nil), // 10: statistics.GetGroupStatisticsReq + (*GetGroupStatisticsResp)(nil), // 11: statistics.GetGroupStatisticsResp + (*GetUserStatisticsReq)(nil), // 12: statistics.GetUserStatisticsReq + (*GetUserStatisticsResp)(nil), // 13: statistics.GetUserStatisticsResp +} +var file_statistics_statistics_proto_depIdxs = []int32{ + 0, // 0: statistics.GetActiveUserReq.StatisticsReq:type_name -> statistics.StatisticsReq + 2, // 1: statistics.GetActiveUserResp.Users:type_name -> statistics.UserResp + 0, // 2: statistics.GetActiveGroupReq.StatisticsReq:type_name -> statistics.StatisticsReq + 5, // 3: statistics.GetActiveGroupResp.Groups:type_name -> statistics.GroupResp + 0, // 4: statistics.GetMessageStatisticsReq.StatisticsReq:type_name -> statistics.StatisticsReq + 7, // 5: statistics.GetMessageStatisticsResp.PrivateMessageNumList:type_name -> statistics.DateNumList + 7, // 6: statistics.GetMessageStatisticsResp.GroupMessageNumList:type_name -> statistics.DateNumList + 0, // 7: statistics.GetGroupStatisticsReq.StatisticsReq:type_name -> statistics.StatisticsReq + 7, // 8: statistics.GetGroupStatisticsResp.IncreaseGroupNumList:type_name -> statistics.DateNumList + 7, // 9: statistics.GetGroupStatisticsResp.TotalGroupNumList:type_name -> statistics.DateNumList + 0, // 10: statistics.GetUserStatisticsReq.StatisticsReq:type_name -> statistics.StatisticsReq + 7, // 11: statistics.GetUserStatisticsResp.IncreaseUserNumList:type_name -> statistics.DateNumList + 7, // 12: statistics.GetUserStatisticsResp.ActiveUserNumList:type_name -> statistics.DateNumList + 7, // 13: statistics.GetUserStatisticsResp.TotalUserNumList:type_name -> statistics.DateNumList + 1, // 14: statistics.user.GetActiveUser:input_type -> statistics.GetActiveUserReq + 4, // 15: statistics.user.GetActiveGroup:input_type -> statistics.GetActiveGroupReq + 8, // 16: statistics.user.GetMessageStatistics:input_type -> statistics.GetMessageStatisticsReq + 10, // 17: statistics.user.GetGroupStatistics:input_type -> statistics.GetGroupStatisticsReq + 12, // 18: statistics.user.GetUserStatistics:input_type -> statistics.GetUserStatisticsReq + 3, // 19: statistics.user.GetActiveUser:output_type -> statistics.GetActiveUserResp + 6, // 20: statistics.user.GetActiveGroup:output_type -> statistics.GetActiveGroupResp + 9, // 21: statistics.user.GetMessageStatistics:output_type -> statistics.GetMessageStatisticsResp + 11, // 22: statistics.user.GetGroupStatistics:output_type -> statistics.GetGroupStatisticsResp + 13, // 23: statistics.user.GetUserStatistics:output_type -> statistics.GetUserStatisticsResp + 19, // [19:24] is the sub-list for method output_type + 14, // [14:19] is the sub-list for method input_type + 14, // [14:14] is the sub-list for extension type_name + 14, // [14:14] is the sub-list for extension extendee + 0, // [0:14] is the sub-list for field type_name +} + +func init() { file_statistics_statistics_proto_init() } +func file_statistics_statistics_proto_init() { + if File_statistics_statistics_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_statistics_statistics_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StatisticsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActiveUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActiveUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActiveGroupReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GroupResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetActiveGroupResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DateNumList); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMessageStatisticsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetMessageStatisticsResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupStatisticsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetGroupStatisticsResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserStatisticsReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_statistics_statistics_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserStatisticsResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_statistics_statistics_proto_rawDesc, + NumEnums: 0, + NumMessages: 14, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_statistics_statistics_proto_goTypes, + DependencyIndexes: file_statistics_statistics_proto_depIdxs, + MessageInfos: file_statistics_statistics_proto_msgTypes, + }.Build() + File_statistics_statistics_proto = out.File + file_statistics_statistics_proto_rawDesc = nil + file_statistics_statistics_proto_goTypes = nil + file_statistics_statistics_proto_depIdxs = nil +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConnInterface + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion6 + +// UserClient is the client API for User service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type UserClient interface { + GetActiveUser(ctx context.Context, in *GetActiveUserReq, opts ...grpc.CallOption) (*GetActiveUserResp, error) + GetActiveGroup(ctx context.Context, in *GetActiveGroupReq, opts ...grpc.CallOption) (*GetActiveGroupResp, error) + GetMessageStatistics(ctx context.Context, in *GetMessageStatisticsReq, opts ...grpc.CallOption) (*GetMessageStatisticsResp, error) + GetGroupStatistics(ctx context.Context, in *GetGroupStatisticsReq, opts ...grpc.CallOption) (*GetGroupStatisticsResp, error) + GetUserStatistics(ctx context.Context, in *GetUserStatisticsReq, opts ...grpc.CallOption) (*GetUserStatisticsResp, error) +} + +type userClient struct { + cc grpc.ClientConnInterface +} + +func NewUserClient(cc grpc.ClientConnInterface) UserClient { + return &userClient{cc} +} + +func (c *userClient) GetActiveUser(ctx context.Context, in *GetActiveUserReq, opts ...grpc.CallOption) (*GetActiveUserResp, error) { + out := new(GetActiveUserResp) + err := c.cc.Invoke(ctx, "/statistics.user/GetActiveUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetActiveGroup(ctx context.Context, in *GetActiveGroupReq, opts ...grpc.CallOption) (*GetActiveGroupResp, error) { + out := new(GetActiveGroupResp) + err := c.cc.Invoke(ctx, "/statistics.user/GetActiveGroup", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetMessageStatistics(ctx context.Context, in *GetMessageStatisticsReq, opts ...grpc.CallOption) (*GetMessageStatisticsResp, error) { + out := new(GetMessageStatisticsResp) + err := c.cc.Invoke(ctx, "/statistics.user/GetMessageStatistics", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetGroupStatistics(ctx context.Context, in *GetGroupStatisticsReq, opts ...grpc.CallOption) (*GetGroupStatisticsResp, error) { + out := new(GetGroupStatisticsResp) + err := c.cc.Invoke(ctx, "/statistics.user/GetGroupStatistics", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetUserStatistics(ctx context.Context, in *GetUserStatisticsReq, opts ...grpc.CallOption) (*GetUserStatisticsResp, error) { + out := new(GetUserStatisticsResp) + err := c.cc.Invoke(ctx, "/statistics.user/GetUserStatistics", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// UserServer is the server API for User service. +type UserServer interface { + GetActiveUser(context.Context, *GetActiveUserReq) (*GetActiveUserResp, error) + GetActiveGroup(context.Context, *GetActiveGroupReq) (*GetActiveGroupResp, error) + GetMessageStatistics(context.Context, *GetMessageStatisticsReq) (*GetMessageStatisticsResp, error) + GetGroupStatistics(context.Context, *GetGroupStatisticsReq) (*GetGroupStatisticsResp, error) + GetUserStatistics(context.Context, *GetUserStatisticsReq) (*GetUserStatisticsResp, error) +} + +// UnimplementedUserServer can be embedded to have forward compatible implementations. +type UnimplementedUserServer struct { +} + +func (*UnimplementedUserServer) GetActiveUser(context.Context, *GetActiveUserReq) (*GetActiveUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetActiveUser not implemented") +} +func (*UnimplementedUserServer) GetActiveGroup(context.Context, *GetActiveGroupReq) (*GetActiveGroupResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetActiveGroup not implemented") +} +func (*UnimplementedUserServer) GetMessageStatistics(context.Context, *GetMessageStatisticsReq) (*GetMessageStatisticsResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetMessageStatistics not implemented") +} +func (*UnimplementedUserServer) GetGroupStatistics(context.Context, *GetGroupStatisticsReq) (*GetGroupStatisticsResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetGroupStatistics not implemented") +} +func (*UnimplementedUserServer) GetUserStatistics(context.Context, *GetUserStatisticsReq) (*GetUserStatisticsResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetUserStatistics not implemented") +} + +func RegisterUserServer(s *grpc.Server, srv UserServer) { + s.RegisterService(&_User_serviceDesc, srv) +} + +func _User_GetActiveUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActiveUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetActiveUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/statistics.user/GetActiveUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetActiveUser(ctx, req.(*GetActiveUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetActiveGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActiveGroupReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetActiveGroup(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/statistics.user/GetActiveGroup", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetActiveGroup(ctx, req.(*GetActiveGroupReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetMessageStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetMessageStatisticsReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetMessageStatistics(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/statistics.user/GetMessageStatistics", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetMessageStatistics(ctx, req.(*GetMessageStatisticsReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetGroupStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetGroupStatisticsReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetGroupStatistics(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/statistics.user/GetGroupStatistics", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetGroupStatistics(ctx, req.(*GetGroupStatisticsReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetUserStatistics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetUserStatisticsReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetUserStatistics(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/statistics.user/GetUserStatistics", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetUserStatistics(ctx, req.(*GetUserStatisticsReq)) + } + return interceptor(ctx, in, info, handler) +} + +var _User_serviceDesc = grpc.ServiceDesc{ + ServiceName: "statistics.user", + HandlerType: (*UserServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetActiveUser", + Handler: _User_GetActiveUser_Handler, + }, + { + MethodName: "GetActiveGroup", + Handler: _User_GetActiveGroup_Handler, + }, + { + MethodName: "GetMessageStatistics", + Handler: _User_GetMessageStatistics_Handler, + }, + { + MethodName: "GetGroupStatistics", + Handler: _User_GetGroupStatistics_Handler, + }, + { + MethodName: "GetUserStatistics", + Handler: _User_GetUserStatistics_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "statistics/statistics.proto", +} diff --git a/pkg/proto/statistics/statistics.proto b/pkg/proto/statistics/statistics.proto new file mode 100644 index 000000000..3c72e4bc5 --- /dev/null +++ b/pkg/proto/statistics/statistics.proto @@ -0,0 +1,93 @@ +syntax = "proto3"; +// import "Open_IM/pkg/proto/sdk_ws/ws.proto"; +option go_package = "./statistics;statistics"; +package statistics; + +message StatisticsReq { + string from = 1; + string to = 2; +} + +message GetActiveUserReq{ + StatisticsReq StatisticsReq = 1; + string OperationID = 2; +} + +message UserResp{ + string NickName = 1; + string UserId = 2; + int32 MessageNum = 3; +} + +message GetActiveUserResp { + repeated UserResp Users = 1; +} + +message GetActiveGroupReq{ + StatisticsReq StatisticsReq = 1; + string OperationID = 2; +} + +message GroupResp { + string GroupName = 1; + string GroupId = 2; + int32 MessageNum = 3; +} + +message GetActiveGroupResp { + repeated GroupResp Groups = 1; +} + +message DateNumList { + string Date = 1; + int32 Num = 2; +} + + +message GetMessageStatisticsReq { + StatisticsReq StatisticsReq = 1; + string OperationID = 2; +} + + +message GetMessageStatisticsResp { + int32 PrivateMessageNum = 1; + int32 GroupMessageNum = 2; + repeated DateNumList PrivateMessageNumList = 3; + repeated DateNumList GroupMessageNumList = 4; +} + +message GetGroupStatisticsReq { + StatisticsReq StatisticsReq = 1; + string OperationID = 2; +} + + +message GetGroupStatisticsResp { + int32 IncreaseGroupNum = 1; + int32 TotalGroupNum = 2; + repeated DateNumList IncreaseGroupNumList = 3; + repeated DateNumList TotalGroupNumList = 4; +} + +message GetUserStatisticsReq { + StatisticsReq StatisticsReq = 1; + string OperationID = 2; +} + +message GetUserStatisticsResp { + int32 IncreaseUserNum = 1; + int32 ActiveUserNum = 2; + int32 TotalUserNum = 3; + repeated DateNumList IncreaseUserNumList = 4; + repeated DateNumList ActiveUserNumList = 5; + repeated DateNumList TotalUserNumList = 6; +} + +service user { + rpc GetActiveUser(GetActiveUserReq) returns(GetActiveUserResp); + rpc GetActiveGroup(GetActiveGroupReq) returns(GetActiveGroupResp); + rpc GetMessageStatistics(GetMessageStatisticsReq) returns(GetMessageStatisticsResp); + rpc GetGroupStatistics(GetGroupStatisticsReq) returns(GetGroupStatisticsResp); + rpc GetUserStatistics(GetUserStatisticsReq) returns(GetUserStatisticsResp); +} \ No newline at end of file diff --git a/pkg/proto/user/user.pb.go b/pkg/proto/user/user.pb.go index c9f85d568..ebe89213f 100644 --- a/pkg/proto/user/user.pb.go +++ b/pkg/proto/user/user.pb.go @@ -1,1007 +1,3640 @@ // Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.27.1 +// protoc v3.15.5 // source: user/user.proto -package user // import "./user" - -import proto "github.com/golang/protobuf/proto" -import fmt "fmt" -import math "math" -import sdk_ws "Open_IM/pkg/proto/sdk_ws" +package user import ( - context "golang.org/x/net/context" + sdk_ws "Open_IM/pkg/proto/sdk_ws" + context "context" grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" ) -// Reference imports to suppress errors if they are not otherwise used. -var _ = proto.Marshal -var _ = fmt.Errorf -var _ = math.Inf - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the proto package it is being compiled against. -// A compilation error at this line likely means your copy of the -// proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) type CommonResp struct { - ErrCode int32 `protobuf:"varint,1,opt,name=errCode" json:"errCode,omitempty"` - ErrMsg string `protobuf:"bytes,2,opt,name=errMsg" json:"errMsg,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ErrCode int32 `protobuf:"varint,1,opt,name=errCode,proto3" json:"errCode,omitempty"` + ErrMsg string `protobuf:"bytes,2,opt,name=errMsg,proto3" json:"errMsg,omitempty"` } -func (m *CommonResp) Reset() { *m = CommonResp{} } -func (m *CommonResp) String() string { return proto.CompactTextString(m) } -func (*CommonResp) ProtoMessage() {} +func (x *CommonResp) Reset() { + *x = CommonResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CommonResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommonResp) ProtoMessage() {} + +func (x *CommonResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommonResp.ProtoReflect.Descriptor instead. func (*CommonResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{0} -} -func (m *CommonResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_CommonResp.Unmarshal(m, b) -} -func (m *CommonResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_CommonResp.Marshal(b, m, deterministic) -} -func (dst *CommonResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_CommonResp.Merge(dst, src) -} -func (m *CommonResp) XXX_Size() int { - return xxx_messageInfo_CommonResp.Size(m) -} -func (m *CommonResp) XXX_DiscardUnknown() { - xxx_messageInfo_CommonResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{0} } -var xxx_messageInfo_CommonResp proto.InternalMessageInfo - -func (m *CommonResp) GetErrCode() int32 { - if m != nil { - return m.ErrCode +func (x *CommonResp) GetErrCode() int32 { + if x != nil { + return x.ErrCode } return 0 } -func (m *CommonResp) GetErrMsg() string { - if m != nil { - return m.ErrMsg +func (x *CommonResp) GetErrMsg() string { + if x != nil { + return x.ErrMsg } return "" } type DeleteUsersReq struct { - DeleteUserIDList []string `protobuf:"bytes,2,rep,name=DeleteUserIDList" json:"DeleteUserIDList,omitempty"` - OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=OperationID" json:"OperationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + DeleteUserIDList []string `protobuf:"bytes,2,rep,name=DeleteUserIDList,proto3" json:"DeleteUserIDList,omitempty"` + OpUserID string `protobuf:"bytes,3,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` + OperationID string `protobuf:"bytes,4,opt,name=OperationID,proto3" json:"OperationID,omitempty"` } -func (m *DeleteUsersReq) Reset() { *m = DeleteUsersReq{} } -func (m *DeleteUsersReq) String() string { return proto.CompactTextString(m) } -func (*DeleteUsersReq) ProtoMessage() {} +func (x *DeleteUsersReq) Reset() { + *x = DeleteUsersReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteUsersReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteUsersReq) ProtoMessage() {} + +func (x *DeleteUsersReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteUsersReq.ProtoReflect.Descriptor instead. func (*DeleteUsersReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{1} -} -func (m *DeleteUsersReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeleteUsersReq.Unmarshal(m, b) -} -func (m *DeleteUsersReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeleteUsersReq.Marshal(b, m, deterministic) -} -func (dst *DeleteUsersReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeleteUsersReq.Merge(dst, src) -} -func (m *DeleteUsersReq) XXX_Size() int { - return xxx_messageInfo_DeleteUsersReq.Size(m) -} -func (m *DeleteUsersReq) XXX_DiscardUnknown() { - xxx_messageInfo_DeleteUsersReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{1} } -var xxx_messageInfo_DeleteUsersReq proto.InternalMessageInfo - -func (m *DeleteUsersReq) GetDeleteUserIDList() []string { - if m != nil { - return m.DeleteUserIDList +func (x *DeleteUsersReq) GetDeleteUserIDList() []string { + if x != nil { + return x.DeleteUserIDList } return nil } -func (m *DeleteUsersReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *DeleteUsersReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } -func (m *DeleteUsersReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *DeleteUsersReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } type DeleteUsersResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp" json:"CommonResp,omitempty"` - FailedUserIDList []string `protobuf:"bytes,2,rep,name=FailedUserIDList" json:"FailedUserIDList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` + FailedUserIDList []string `protobuf:"bytes,2,rep,name=FailedUserIDList,proto3" json:"FailedUserIDList,omitempty"` } -func (m *DeleteUsersResp) Reset() { *m = DeleteUsersResp{} } -func (m *DeleteUsersResp) String() string { return proto.CompactTextString(m) } -func (*DeleteUsersResp) ProtoMessage() {} +func (x *DeleteUsersResp) Reset() { + *x = DeleteUsersResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteUsersResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteUsersResp) ProtoMessage() {} + +func (x *DeleteUsersResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteUsersResp.ProtoReflect.Descriptor instead. func (*DeleteUsersResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{2} -} -func (m *DeleteUsersResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_DeleteUsersResp.Unmarshal(m, b) -} -func (m *DeleteUsersResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_DeleteUsersResp.Marshal(b, m, deterministic) -} -func (dst *DeleteUsersResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_DeleteUsersResp.Merge(dst, src) -} -func (m *DeleteUsersResp) XXX_Size() int { - return xxx_messageInfo_DeleteUsersResp.Size(m) -} -func (m *DeleteUsersResp) XXX_DiscardUnknown() { - xxx_messageInfo_DeleteUsersResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{2} } -var xxx_messageInfo_DeleteUsersResp proto.InternalMessageInfo - -func (m *DeleteUsersResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *DeleteUsersResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *DeleteUsersResp) GetFailedUserIDList() []string { - if m != nil { - return m.FailedUserIDList +func (x *DeleteUsersResp) GetFailedUserIDList() []string { + if x != nil { + return x.FailedUserIDList } return nil } type GetAllUserIDReq struct { - OpUserID string `protobuf:"bytes,1,opt,name=opUserID" json:"opUserID,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OpUserID string `protobuf:"bytes,1,opt,name=opUserID,proto3" json:"opUserID,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=operationID,proto3" json:"operationID,omitempty"` } -func (m *GetAllUserIDReq) Reset() { *m = GetAllUserIDReq{} } -func (m *GetAllUserIDReq) String() string { return proto.CompactTextString(m) } -func (*GetAllUserIDReq) ProtoMessage() {} +func (x *GetAllUserIDReq) Reset() { + *x = GetAllUserIDReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAllUserIDReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAllUserIDReq) ProtoMessage() {} + +func (x *GetAllUserIDReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetAllUserIDReq.ProtoReflect.Descriptor instead. func (*GetAllUserIDReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{3} -} -func (m *GetAllUserIDReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAllUserIDReq.Unmarshal(m, b) -} -func (m *GetAllUserIDReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAllUserIDReq.Marshal(b, m, deterministic) -} -func (dst *GetAllUserIDReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllUserIDReq.Merge(dst, src) -} -func (m *GetAllUserIDReq) XXX_Size() int { - return xxx_messageInfo_GetAllUserIDReq.Size(m) -} -func (m *GetAllUserIDReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetAllUserIDReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{3} } -var xxx_messageInfo_GetAllUserIDReq proto.InternalMessageInfo - -func (m *GetAllUserIDReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *GetAllUserIDReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } -func (m *GetAllUserIDReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *GetAllUserIDReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } type GetAllUserIDResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp" json:"CommonResp,omitempty"` - UserIDList []string `protobuf:"bytes,2,rep,name=UserIDList" json:"UserIDList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` + UserIDList []string `protobuf:"bytes,2,rep,name=UserIDList,proto3" json:"UserIDList,omitempty"` } -func (m *GetAllUserIDResp) Reset() { *m = GetAllUserIDResp{} } -func (m *GetAllUserIDResp) String() string { return proto.CompactTextString(m) } -func (*GetAllUserIDResp) ProtoMessage() {} +func (x *GetAllUserIDResp) Reset() { + *x = GetAllUserIDResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAllUserIDResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAllUserIDResp) ProtoMessage() {} + +func (x *GetAllUserIDResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetAllUserIDResp.ProtoReflect.Descriptor instead. func (*GetAllUserIDResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{4} -} -func (m *GetAllUserIDResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAllUserIDResp.Unmarshal(m, b) -} -func (m *GetAllUserIDResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAllUserIDResp.Marshal(b, m, deterministic) -} -func (dst *GetAllUserIDResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllUserIDResp.Merge(dst, src) -} -func (m *GetAllUserIDResp) XXX_Size() int { - return xxx_messageInfo_GetAllUserIDResp.Size(m) -} -func (m *GetAllUserIDResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetAllUserIDResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{4} } -var xxx_messageInfo_GetAllUserIDResp proto.InternalMessageInfo - -func (m *GetAllUserIDResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *GetAllUserIDResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *GetAllUserIDResp) GetUserIDList() []string { - if m != nil { - return m.UserIDList +func (x *GetAllUserIDResp) GetUserIDList() []string { + if x != nil { + return x.UserIDList } return nil } type AccountCheckReq struct { - CheckUserIDList []string `protobuf:"bytes,1,rep,name=CheckUserIDList" json:"CheckUserIDList,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=OpUserID" json:"OpUserID,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=OperationID" json:"OperationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CheckUserIDList []string `protobuf:"bytes,1,rep,name=CheckUserIDList,proto3" json:"CheckUserIDList,omitempty"` + OpUserID string `protobuf:"bytes,2,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` } -func (m *AccountCheckReq) Reset() { *m = AccountCheckReq{} } -func (m *AccountCheckReq) String() string { return proto.CompactTextString(m) } -func (*AccountCheckReq) ProtoMessage() {} +func (x *AccountCheckReq) Reset() { + *x = AccountCheckReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AccountCheckReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AccountCheckReq) ProtoMessage() {} + +func (x *AccountCheckReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AccountCheckReq.ProtoReflect.Descriptor instead. func (*AccountCheckReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{5} -} -func (m *AccountCheckReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AccountCheckReq.Unmarshal(m, b) -} -func (m *AccountCheckReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AccountCheckReq.Marshal(b, m, deterministic) -} -func (dst *AccountCheckReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_AccountCheckReq.Merge(dst, src) -} -func (m *AccountCheckReq) XXX_Size() int { - return xxx_messageInfo_AccountCheckReq.Size(m) -} -func (m *AccountCheckReq) XXX_DiscardUnknown() { - xxx_messageInfo_AccountCheckReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{5} } -var xxx_messageInfo_AccountCheckReq proto.InternalMessageInfo - -func (m *AccountCheckReq) GetCheckUserIDList() []string { - if m != nil { - return m.CheckUserIDList +func (x *AccountCheckReq) GetCheckUserIDList() []string { + if x != nil { + return x.CheckUserIDList } return nil } -func (m *AccountCheckReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *AccountCheckReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } -func (m *AccountCheckReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *AccountCheckReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } type AccountCheckResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - ResultList []*AccountCheckResp_SingleUserStatus `protobuf:"bytes,2,rep,name=ResultList" json:"ResultList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` + ResultList []*AccountCheckResp_SingleUserStatus `protobuf:"bytes,2,rep,name=ResultList,proto3" json:"ResultList,omitempty"` } -func (m *AccountCheckResp) Reset() { *m = AccountCheckResp{} } -func (m *AccountCheckResp) String() string { return proto.CompactTextString(m) } -func (*AccountCheckResp) ProtoMessage() {} +func (x *AccountCheckResp) Reset() { + *x = AccountCheckResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AccountCheckResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AccountCheckResp) ProtoMessage() {} + +func (x *AccountCheckResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AccountCheckResp.ProtoReflect.Descriptor instead. func (*AccountCheckResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{6} -} -func (m *AccountCheckResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AccountCheckResp.Unmarshal(m, b) -} -func (m *AccountCheckResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AccountCheckResp.Marshal(b, m, deterministic) -} -func (dst *AccountCheckResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_AccountCheckResp.Merge(dst, src) -} -func (m *AccountCheckResp) XXX_Size() int { - return xxx_messageInfo_AccountCheckResp.Size(m) -} -func (m *AccountCheckResp) XXX_DiscardUnknown() { - xxx_messageInfo_AccountCheckResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{6} } -var xxx_messageInfo_AccountCheckResp proto.InternalMessageInfo - -func (m *AccountCheckResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *AccountCheckResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *AccountCheckResp) GetResultList() []*AccountCheckResp_SingleUserStatus { - if m != nil { - return m.ResultList +func (x *AccountCheckResp) GetResultList() []*AccountCheckResp_SingleUserStatus { + if x != nil { + return x.ResultList } return nil } -type AccountCheckResp_SingleUserStatus struct { - UserID string `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"` - AccountStatus string `protobuf:"bytes,2,opt,name=accountStatus" json:"accountStatus,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` -} - -func (m *AccountCheckResp_SingleUserStatus) Reset() { *m = AccountCheckResp_SingleUserStatus{} } -func (m *AccountCheckResp_SingleUserStatus) String() string { return proto.CompactTextString(m) } -func (*AccountCheckResp_SingleUserStatus) ProtoMessage() {} -func (*AccountCheckResp_SingleUserStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{6, 0} -} -func (m *AccountCheckResp_SingleUserStatus) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Unmarshal(m, b) -} -func (m *AccountCheckResp_SingleUserStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Marshal(b, m, deterministic) -} -func (dst *AccountCheckResp_SingleUserStatus) XXX_Merge(src proto.Message) { - xxx_messageInfo_AccountCheckResp_SingleUserStatus.Merge(dst, src) -} -func (m *AccountCheckResp_SingleUserStatus) XXX_Size() int { - return xxx_messageInfo_AccountCheckResp_SingleUserStatus.Size(m) -} -func (m *AccountCheckResp_SingleUserStatus) XXX_DiscardUnknown() { - xxx_messageInfo_AccountCheckResp_SingleUserStatus.DiscardUnknown(m) -} - -var xxx_messageInfo_AccountCheckResp_SingleUserStatus proto.InternalMessageInfo - -func (m *AccountCheckResp_SingleUserStatus) GetUserID() string { - if m != nil { - return m.UserID - } - return "" -} - -func (m *AccountCheckResp_SingleUserStatus) GetAccountStatus() string { - if m != nil { - return m.AccountStatus - } - return "" -} - type GetUserInfoReq struct { - UserIDList []string `protobuf:"bytes,1,rep,name=userIDList" json:"userIDList,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=OpUserID" json:"OpUserID,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=OperationID" json:"OperationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserIDList []string `protobuf:"bytes,1,rep,name=userIDList,proto3" json:"userIDList,omitempty"` + OpUserID string `protobuf:"bytes,2,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` } -func (m *GetUserInfoReq) Reset() { *m = GetUserInfoReq{} } -func (m *GetUserInfoReq) String() string { return proto.CompactTextString(m) } -func (*GetUserInfoReq) ProtoMessage() {} +func (x *GetUserInfoReq) Reset() { + *x = GetUserInfoReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserInfoReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserInfoReq) ProtoMessage() {} + +func (x *GetUserInfoReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserInfoReq.ProtoReflect.Descriptor instead. func (*GetUserInfoReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{7} -} -func (m *GetUserInfoReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetUserInfoReq.Unmarshal(m, b) -} -func (m *GetUserInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetUserInfoReq.Marshal(b, m, deterministic) -} -func (dst *GetUserInfoReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetUserInfoReq.Merge(dst, src) -} -func (m *GetUserInfoReq) XXX_Size() int { - return xxx_messageInfo_GetUserInfoReq.Size(m) -} -func (m *GetUserInfoReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetUserInfoReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{7} } -var xxx_messageInfo_GetUserInfoReq proto.InternalMessageInfo - -func (m *GetUserInfoReq) GetUserIDList() []string { - if m != nil { - return m.UserIDList +func (x *GetUserInfoReq) GetUserIDList() []string { + if x != nil { + return x.UserIDList } return nil } -func (m *GetUserInfoReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *GetUserInfoReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } -func (m *GetUserInfoReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *GetUserInfoReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } type GetUserInfoResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - UserInfoList []*sdk_ws.UserInfo `protobuf:"bytes,3,rep,name=UserInfoList" json:"UserInfoList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` + UserInfoList []*sdk_ws.UserInfo `protobuf:"bytes,3,rep,name=UserInfoList,proto3" json:"UserInfoList,omitempty"` } -func (m *GetUserInfoResp) Reset() { *m = GetUserInfoResp{} } -func (m *GetUserInfoResp) String() string { return proto.CompactTextString(m) } -func (*GetUserInfoResp) ProtoMessage() {} +func (x *GetUserInfoResp) Reset() { + *x = GetUserInfoResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserInfoResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserInfoResp) ProtoMessage() {} + +func (x *GetUserInfoResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserInfoResp.ProtoReflect.Descriptor instead. func (*GetUserInfoResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{8} -} -func (m *GetUserInfoResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetUserInfoResp.Unmarshal(m, b) -} -func (m *GetUserInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetUserInfoResp.Marshal(b, m, deterministic) -} -func (dst *GetUserInfoResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetUserInfoResp.Merge(dst, src) -} -func (m *GetUserInfoResp) XXX_Size() int { - return xxx_messageInfo_GetUserInfoResp.Size(m) -} -func (m *GetUserInfoResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetUserInfoResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{8} } -var xxx_messageInfo_GetUserInfoResp proto.InternalMessageInfo - -func (m *GetUserInfoResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *GetUserInfoResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *GetUserInfoResp) GetUserInfoList() []*sdk_ws.UserInfo { - if m != nil { - return m.UserInfoList +func (x *GetUserInfoResp) GetUserInfoList() []*sdk_ws.UserInfo { + if x != nil { + return x.UserInfoList } return nil } type UpdateUserInfoReq struct { - UserInfo *sdk_ws.UserInfo `protobuf:"bytes,1,opt,name=UserInfo" json:"UserInfo,omitempty"` - OpUserID string `protobuf:"bytes,2,opt,name=OpUserID" json:"OpUserID,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserInfo *sdk_ws.UserInfo `protobuf:"bytes,1,opt,name=UserInfo,proto3" json:"UserInfo,omitempty"` + OpUserID string `protobuf:"bytes,2,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=operationID,proto3" json:"operationID,omitempty"` } -func (m *UpdateUserInfoReq) Reset() { *m = UpdateUserInfoReq{} } -func (m *UpdateUserInfoReq) String() string { return proto.CompactTextString(m) } -func (*UpdateUserInfoReq) ProtoMessage() {} +func (x *UpdateUserInfoReq) Reset() { + *x = UpdateUserInfoReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateUserInfoReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateUserInfoReq) ProtoMessage() {} + +func (x *UpdateUserInfoReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateUserInfoReq.ProtoReflect.Descriptor instead. func (*UpdateUserInfoReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{9} -} -func (m *UpdateUserInfoReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UpdateUserInfoReq.Unmarshal(m, b) -} -func (m *UpdateUserInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UpdateUserInfoReq.Marshal(b, m, deterministic) -} -func (dst *UpdateUserInfoReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_UpdateUserInfoReq.Merge(dst, src) -} -func (m *UpdateUserInfoReq) XXX_Size() int { - return xxx_messageInfo_UpdateUserInfoReq.Size(m) -} -func (m *UpdateUserInfoReq) XXX_DiscardUnknown() { - xxx_messageInfo_UpdateUserInfoReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{9} } -var xxx_messageInfo_UpdateUserInfoReq proto.InternalMessageInfo - -func (m *UpdateUserInfoReq) GetUserInfo() *sdk_ws.UserInfo { - if m != nil { - return m.UserInfo +func (x *UpdateUserInfoReq) GetUserInfo() *sdk_ws.UserInfo { + if x != nil { + return x.UserInfo } return nil } -func (m *UpdateUserInfoReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *UpdateUserInfoReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } -func (m *UpdateUserInfoReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *UpdateUserInfoReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } type UpdateUserInfoResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` } -func (m *UpdateUserInfoResp) Reset() { *m = UpdateUserInfoResp{} } -func (m *UpdateUserInfoResp) String() string { return proto.CompactTextString(m) } -func (*UpdateUserInfoResp) ProtoMessage() {} +func (x *UpdateUserInfoResp) Reset() { + *x = UpdateUserInfoResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateUserInfoResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateUserInfoResp) ProtoMessage() {} + +func (x *UpdateUserInfoResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateUserInfoResp.ProtoReflect.Descriptor instead. func (*UpdateUserInfoResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{10} -} -func (m *UpdateUserInfoResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_UpdateUserInfoResp.Unmarshal(m, b) -} -func (m *UpdateUserInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_UpdateUserInfoResp.Marshal(b, m, deterministic) -} -func (dst *UpdateUserInfoResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_UpdateUserInfoResp.Merge(dst, src) -} -func (m *UpdateUserInfoResp) XXX_Size() int { - return xxx_messageInfo_UpdateUserInfoResp.Size(m) -} -func (m *UpdateUserInfoResp) XXX_DiscardUnknown() { - xxx_messageInfo_UpdateUserInfoResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{10} } -var xxx_messageInfo_UpdateUserInfoResp proto.InternalMessageInfo - -func (m *UpdateUserInfoResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *UpdateUserInfoResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } type SetReceiveMessageOptReq struct { - FromUserID string `protobuf:"bytes,1,opt,name=FromUserID" json:"FromUserID,omitempty"` - Opt int32 `protobuf:"varint,2,opt,name=opt" json:"opt,omitempty"` - ConversationIDList []string `protobuf:"bytes,3,rep,name=conversationIDList" json:"conversationIDList,omitempty"` - OperationID string `protobuf:"bytes,4,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,5,opt,name=OpUserID" json:"OpUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromUserID string `protobuf:"bytes,1,opt,name=FromUserID,proto3" json:"FromUserID,omitempty"` + Opt int32 `protobuf:"varint,2,opt,name=opt,proto3" json:"opt,omitempty"` + ConversationIDList []string `protobuf:"bytes,3,rep,name=conversationIDList,proto3" json:"conversationIDList,omitempty"` + OperationID string `protobuf:"bytes,4,opt,name=operationID,proto3" json:"operationID,omitempty"` + OpUserID string `protobuf:"bytes,5,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` } -func (m *SetReceiveMessageOptReq) Reset() { *m = SetReceiveMessageOptReq{} } -func (m *SetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) } -func (*SetReceiveMessageOptReq) ProtoMessage() {} +func (x *SetReceiveMessageOptReq) Reset() { + *x = SetReceiveMessageOptReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetReceiveMessageOptReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetReceiveMessageOptReq) ProtoMessage() {} + +func (x *SetReceiveMessageOptReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetReceiveMessageOptReq.ProtoReflect.Descriptor instead. func (*SetReceiveMessageOptReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{11} -} -func (m *SetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetReceiveMessageOptReq.Unmarshal(m, b) -} -func (m *SetReceiveMessageOptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetReceiveMessageOptReq.Marshal(b, m, deterministic) -} -func (dst *SetReceiveMessageOptReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetReceiveMessageOptReq.Merge(dst, src) -} -func (m *SetReceiveMessageOptReq) XXX_Size() int { - return xxx_messageInfo_SetReceiveMessageOptReq.Size(m) -} -func (m *SetReceiveMessageOptReq) XXX_DiscardUnknown() { - xxx_messageInfo_SetReceiveMessageOptReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{11} } -var xxx_messageInfo_SetReceiveMessageOptReq proto.InternalMessageInfo - -func (m *SetReceiveMessageOptReq) GetFromUserID() string { - if m != nil { - return m.FromUserID +func (x *SetReceiveMessageOptReq) GetFromUserID() string { + if x != nil { + return x.FromUserID } return "" } -func (m *SetReceiveMessageOptReq) GetOpt() int32 { - if m != nil { - return m.Opt +func (x *SetReceiveMessageOptReq) GetOpt() int32 { + if x != nil { + return x.Opt } return 0 } -func (m *SetReceiveMessageOptReq) GetConversationIDList() []string { - if m != nil { - return m.ConversationIDList +func (x *SetReceiveMessageOptReq) GetConversationIDList() []string { + if x != nil { + return x.ConversationIDList } return nil } -func (m *SetReceiveMessageOptReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *SetReceiveMessageOptReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } -func (m *SetReceiveMessageOptReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *SetReceiveMessageOptReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } type OptResult struct { - ConversationID string `protobuf:"bytes,1,opt,name=conversationID" json:"conversationID,omitempty"` - Result int32 `protobuf:"varint,2,opt,name=result" json:"result,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ConversationID string `protobuf:"bytes,1,opt,name=conversationID,proto3" json:"conversationID,omitempty"` + Result int32 `protobuf:"varint,2,opt,name=result,proto3" json:"result,omitempty"` //-1: failed; 0:default; 1: not receive ; 2: not jpush } -func (m *OptResult) Reset() { *m = OptResult{} } -func (m *OptResult) String() string { return proto.CompactTextString(m) } -func (*OptResult) ProtoMessage() {} +func (x *OptResult) Reset() { + *x = OptResult{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *OptResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OptResult) ProtoMessage() {} + +func (x *OptResult) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OptResult.ProtoReflect.Descriptor instead. func (*OptResult) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{12} -} -func (m *OptResult) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_OptResult.Unmarshal(m, b) -} -func (m *OptResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_OptResult.Marshal(b, m, deterministic) -} -func (dst *OptResult) XXX_Merge(src proto.Message) { - xxx_messageInfo_OptResult.Merge(dst, src) -} -func (m *OptResult) XXX_Size() int { - return xxx_messageInfo_OptResult.Size(m) -} -func (m *OptResult) XXX_DiscardUnknown() { - xxx_messageInfo_OptResult.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{12} } -var xxx_messageInfo_OptResult proto.InternalMessageInfo - -func (m *OptResult) GetConversationID() string { - if m != nil { - return m.ConversationID +func (x *OptResult) GetConversationID() string { + if x != nil { + return x.ConversationID } return "" } -func (m *OptResult) GetResult() int32 { - if m != nil { - return m.Result +func (x *OptResult) GetResult() int32 { + if x != nil { + return x.Result } return 0 } type SetReceiveMessageOptResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - ConversationOptResultList []*OptResult `protobuf:"bytes,2,rep,name=conversationOptResultList" json:"conversationOptResultList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` + ConversationOptResultList []*OptResult `protobuf:"bytes,2,rep,name=conversationOptResultList,proto3" json:"conversationOptResultList,omitempty"` } -func (m *SetReceiveMessageOptResp) Reset() { *m = SetReceiveMessageOptResp{} } -func (m *SetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) } -func (*SetReceiveMessageOptResp) ProtoMessage() {} +func (x *SetReceiveMessageOptResp) Reset() { + *x = SetReceiveMessageOptResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *SetReceiveMessageOptResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SetReceiveMessageOptResp) ProtoMessage() {} + +func (x *SetReceiveMessageOptResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SetReceiveMessageOptResp.ProtoReflect.Descriptor instead. func (*SetReceiveMessageOptResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{13} -} -func (m *SetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_SetReceiveMessageOptResp.Unmarshal(m, b) -} -func (m *SetReceiveMessageOptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_SetReceiveMessageOptResp.Marshal(b, m, deterministic) -} -func (dst *SetReceiveMessageOptResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_SetReceiveMessageOptResp.Merge(dst, src) -} -func (m *SetReceiveMessageOptResp) XXX_Size() int { - return xxx_messageInfo_SetReceiveMessageOptResp.Size(m) -} -func (m *SetReceiveMessageOptResp) XXX_DiscardUnknown() { - xxx_messageInfo_SetReceiveMessageOptResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{13} } -var xxx_messageInfo_SetReceiveMessageOptResp proto.InternalMessageInfo - -func (m *SetReceiveMessageOptResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *SetReceiveMessageOptResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *SetReceiveMessageOptResp) GetConversationOptResultList() []*OptResult { - if m != nil { - return m.ConversationOptResultList +func (x *SetReceiveMessageOptResp) GetConversationOptResultList() []*OptResult { + if x != nil { + return x.ConversationOptResultList } return nil } type GetReceiveMessageOptReq struct { - FromUserID string `protobuf:"bytes,1,opt,name=FromUserID" json:"FromUserID,omitempty"` - ConversationIDList []string `protobuf:"bytes,2,rep,name=conversationIDList" json:"conversationIDList,omitempty"` - OperationID string `protobuf:"bytes,3,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,4,opt,name=OpUserID" json:"OpUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromUserID string `protobuf:"bytes,1,opt,name=FromUserID,proto3" json:"FromUserID,omitempty"` + ConversationIDList []string `protobuf:"bytes,2,rep,name=conversationIDList,proto3" json:"conversationIDList,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=operationID,proto3" json:"operationID,omitempty"` + OpUserID string `protobuf:"bytes,4,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` } -func (m *GetReceiveMessageOptReq) Reset() { *m = GetReceiveMessageOptReq{} } -func (m *GetReceiveMessageOptReq) String() string { return proto.CompactTextString(m) } -func (*GetReceiveMessageOptReq) ProtoMessage() {} +func (x *GetReceiveMessageOptReq) Reset() { + *x = GetReceiveMessageOptReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetReceiveMessageOptReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetReceiveMessageOptReq) ProtoMessage() {} + +func (x *GetReceiveMessageOptReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetReceiveMessageOptReq.ProtoReflect.Descriptor instead. func (*GetReceiveMessageOptReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{14} -} -func (m *GetReceiveMessageOptReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetReceiveMessageOptReq.Unmarshal(m, b) -} -func (m *GetReceiveMessageOptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetReceiveMessageOptReq.Marshal(b, m, deterministic) -} -func (dst *GetReceiveMessageOptReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetReceiveMessageOptReq.Merge(dst, src) -} -func (m *GetReceiveMessageOptReq) XXX_Size() int { - return xxx_messageInfo_GetReceiveMessageOptReq.Size(m) -} -func (m *GetReceiveMessageOptReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetReceiveMessageOptReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{14} } -var xxx_messageInfo_GetReceiveMessageOptReq proto.InternalMessageInfo - -func (m *GetReceiveMessageOptReq) GetFromUserID() string { - if m != nil { - return m.FromUserID +func (x *GetReceiveMessageOptReq) GetFromUserID() string { + if x != nil { + return x.FromUserID } return "" } -func (m *GetReceiveMessageOptReq) GetConversationIDList() []string { - if m != nil { - return m.ConversationIDList +func (x *GetReceiveMessageOptReq) GetConversationIDList() []string { + if x != nil { + return x.ConversationIDList } return nil } -func (m *GetReceiveMessageOptReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *GetReceiveMessageOptReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } -func (m *GetReceiveMessageOptReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *GetReceiveMessageOptReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } type GetReceiveMessageOptResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - ConversationOptResultList []*OptResult `protobuf:"bytes,3,rep,name=conversationOptResultList" json:"conversationOptResultList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` + ConversationOptResultList []*OptResult `protobuf:"bytes,3,rep,name=conversationOptResultList,proto3" json:"conversationOptResultList,omitempty"` } -func (m *GetReceiveMessageOptResp) Reset() { *m = GetReceiveMessageOptResp{} } -func (m *GetReceiveMessageOptResp) String() string { return proto.CompactTextString(m) } -func (*GetReceiveMessageOptResp) ProtoMessage() {} +func (x *GetReceiveMessageOptResp) Reset() { + *x = GetReceiveMessageOptResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetReceiveMessageOptResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetReceiveMessageOptResp) ProtoMessage() {} + +func (x *GetReceiveMessageOptResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetReceiveMessageOptResp.ProtoReflect.Descriptor instead. func (*GetReceiveMessageOptResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{15} -} -func (m *GetReceiveMessageOptResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetReceiveMessageOptResp.Unmarshal(m, b) -} -func (m *GetReceiveMessageOptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetReceiveMessageOptResp.Marshal(b, m, deterministic) -} -func (dst *GetReceiveMessageOptResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetReceiveMessageOptResp.Merge(dst, src) -} -func (m *GetReceiveMessageOptResp) XXX_Size() int { - return xxx_messageInfo_GetReceiveMessageOptResp.Size(m) -} -func (m *GetReceiveMessageOptResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetReceiveMessageOptResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{15} } -var xxx_messageInfo_GetReceiveMessageOptResp proto.InternalMessageInfo - -func (m *GetReceiveMessageOptResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *GetReceiveMessageOptResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *GetReceiveMessageOptResp) GetConversationOptResultList() []*OptResult { - if m != nil { - return m.ConversationOptResultList +func (x *GetReceiveMessageOptResp) GetConversationOptResultList() []*OptResult { + if x != nil { + return x.ConversationOptResultList } return nil } type GetAllConversationMsgOptReq struct { - FromUserID string `protobuf:"bytes,1,opt,name=FromUserID" json:"FromUserID,omitempty"` - OperationID string `protobuf:"bytes,2,opt,name=operationID" json:"operationID,omitempty"` - OpUserID string `protobuf:"bytes,3,opt,name=OpUserID" json:"OpUserID,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FromUserID string `protobuf:"bytes,1,opt,name=FromUserID,proto3" json:"FromUserID,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=operationID,proto3" json:"operationID,omitempty"` + OpUserID string `protobuf:"bytes,3,opt,name=OpUserID,proto3" json:"OpUserID,omitempty"` } -func (m *GetAllConversationMsgOptReq) Reset() { *m = GetAllConversationMsgOptReq{} } -func (m *GetAllConversationMsgOptReq) String() string { return proto.CompactTextString(m) } -func (*GetAllConversationMsgOptReq) ProtoMessage() {} +func (x *GetAllConversationMsgOptReq) Reset() { + *x = GetAllConversationMsgOptReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAllConversationMsgOptReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAllConversationMsgOptReq) ProtoMessage() {} + +func (x *GetAllConversationMsgOptReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetAllConversationMsgOptReq.ProtoReflect.Descriptor instead. func (*GetAllConversationMsgOptReq) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{16} -} -func (m *GetAllConversationMsgOptReq) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAllConversationMsgOptReq.Unmarshal(m, b) -} -func (m *GetAllConversationMsgOptReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAllConversationMsgOptReq.Marshal(b, m, deterministic) -} -func (dst *GetAllConversationMsgOptReq) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllConversationMsgOptReq.Merge(dst, src) -} -func (m *GetAllConversationMsgOptReq) XXX_Size() int { - return xxx_messageInfo_GetAllConversationMsgOptReq.Size(m) -} -func (m *GetAllConversationMsgOptReq) XXX_DiscardUnknown() { - xxx_messageInfo_GetAllConversationMsgOptReq.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{16} } -var xxx_messageInfo_GetAllConversationMsgOptReq proto.InternalMessageInfo - -func (m *GetAllConversationMsgOptReq) GetFromUserID() string { - if m != nil { - return m.FromUserID +func (x *GetAllConversationMsgOptReq) GetFromUserID() string { + if x != nil { + return x.FromUserID } return "" } -func (m *GetAllConversationMsgOptReq) GetOperationID() string { - if m != nil { - return m.OperationID +func (x *GetAllConversationMsgOptReq) GetOperationID() string { + if x != nil { + return x.OperationID } return "" } -func (m *GetAllConversationMsgOptReq) GetOpUserID() string { - if m != nil { - return m.OpUserID +func (x *GetAllConversationMsgOptReq) GetOpUserID() string { + if x != nil { + return x.OpUserID } return "" } type GetAllConversationMsgOptResp struct { - CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp" json:"commonResp,omitempty"` - ConversationOptResultList []*OptResult `protobuf:"bytes,3,rep,name=conversationOptResultList" json:"conversationOptResultList,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` + ConversationOptResultList []*OptResult `protobuf:"bytes,3,rep,name=conversationOptResultList,proto3" json:"conversationOptResultList,omitempty"` } -func (m *GetAllConversationMsgOptResp) Reset() { *m = GetAllConversationMsgOptResp{} } -func (m *GetAllConversationMsgOptResp) String() string { return proto.CompactTextString(m) } -func (*GetAllConversationMsgOptResp) ProtoMessage() {} +func (x *GetAllConversationMsgOptResp) Reset() { + *x = GetAllConversationMsgOptResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetAllConversationMsgOptResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetAllConversationMsgOptResp) ProtoMessage() {} + +func (x *GetAllConversationMsgOptResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetAllConversationMsgOptResp.ProtoReflect.Descriptor instead. func (*GetAllConversationMsgOptResp) Descriptor() ([]byte, []int) { - return fileDescriptor_user_9cd4aaf870b6d3b5, []int{17} -} -func (m *GetAllConversationMsgOptResp) XXX_Unmarshal(b []byte) error { - return xxx_messageInfo_GetAllConversationMsgOptResp.Unmarshal(m, b) -} -func (m *GetAllConversationMsgOptResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - return xxx_messageInfo_GetAllConversationMsgOptResp.Marshal(b, m, deterministic) -} -func (dst *GetAllConversationMsgOptResp) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetAllConversationMsgOptResp.Merge(dst, src) -} -func (m *GetAllConversationMsgOptResp) XXX_Size() int { - return xxx_messageInfo_GetAllConversationMsgOptResp.Size(m) -} -func (m *GetAllConversationMsgOptResp) XXX_DiscardUnknown() { - xxx_messageInfo_GetAllConversationMsgOptResp.DiscardUnknown(m) + return file_user_user_proto_rawDescGZIP(), []int{17} } -var xxx_messageInfo_GetAllConversationMsgOptResp proto.InternalMessageInfo - -func (m *GetAllConversationMsgOptResp) GetCommonResp() *CommonResp { - if m != nil { - return m.CommonResp +func (x *GetAllConversationMsgOptResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp } return nil } -func (m *GetAllConversationMsgOptResp) GetConversationOptResultList() []*OptResult { - if m != nil { - return m.ConversationOptResultList +func (x *GetAllConversationMsgOptResp) GetConversationOptResultList() []*OptResult { + if x != nil { + return x.ConversationOptResultList } return nil } -func init() { - proto.RegisterType((*CommonResp)(nil), "user.CommonResp") - proto.RegisterType((*DeleteUsersReq)(nil), "user.DeleteUsersReq") - proto.RegisterType((*DeleteUsersResp)(nil), "user.DeleteUsersResp") - proto.RegisterType((*GetAllUserIDReq)(nil), "user.GetAllUserIDReq") - proto.RegisterType((*GetAllUserIDResp)(nil), "user.GetAllUserIDResp") - proto.RegisterType((*AccountCheckReq)(nil), "user.AccountCheckReq") - proto.RegisterType((*AccountCheckResp)(nil), "user.AccountCheckResp") - proto.RegisterType((*AccountCheckResp_SingleUserStatus)(nil), "user.AccountCheckResp.SingleUserStatus") - proto.RegisterType((*GetUserInfoReq)(nil), "user.GetUserInfoReq") - proto.RegisterType((*GetUserInfoResp)(nil), "user.GetUserInfoResp") - proto.RegisterType((*UpdateUserInfoReq)(nil), "user.UpdateUserInfoReq") - proto.RegisterType((*UpdateUserInfoResp)(nil), "user.UpdateUserInfoResp") - proto.RegisterType((*SetReceiveMessageOptReq)(nil), "user.SetReceiveMessageOptReq") - proto.RegisterType((*OptResult)(nil), "user.OptResult") - proto.RegisterType((*SetReceiveMessageOptResp)(nil), "user.SetReceiveMessageOptResp") - proto.RegisterType((*GetReceiveMessageOptReq)(nil), "user.GetReceiveMessageOptReq") - proto.RegisterType((*GetReceiveMessageOptResp)(nil), "user.GetReceiveMessageOptResp") - proto.RegisterType((*GetAllConversationMsgOptReq)(nil), "user.GetAllConversationMsgOptReq") - proto.RegisterType((*GetAllConversationMsgOptResp)(nil), "user.GetAllConversationMsgOptResp") +type ResignUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=UserId,proto3" json:"UserId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *ResignUserReq) Reset() { + *x = ResignUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ResignUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResignUserReq) ProtoMessage() {} + +func (x *ResignUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResignUserReq.ProtoReflect.Descriptor instead. +func (*ResignUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{18} +} + +func (x *ResignUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *ResignUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type ResignUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=commonResp,proto3" json:"commonResp,omitempty"` +} + +func (x *ResignUserResp) Reset() { + *x = ResignUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ResignUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResignUserResp) ProtoMessage() {} + +func (x *ResignUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResignUserResp.ProtoReflect.Descriptor instead. +func (*ResignUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{19} +} + +func (x *ResignUserResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +type GetUserByIdReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=UserId,proto3" json:"UserId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetUserByIdReq) Reset() { + *x = GetUserByIdReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserByIdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserByIdReq) ProtoMessage() {} + +func (x *GetUserByIdReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserByIdReq.ProtoReflect.Descriptor instead. +func (*GetUserByIdReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{20} +} + +func (x *GetUserByIdReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *GetUserByIdReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type User struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ProfilePhoto string `protobuf:"bytes,1,opt,name=ProfilePhoto,proto3" json:"ProfilePhoto,omitempty"` + Nickname string `protobuf:"bytes,2,opt,name=Nickname,proto3" json:"Nickname,omitempty"` + UserId string `protobuf:"bytes,3,opt,name=UserId,proto3" json:"UserId,omitempty"` + CreateTime string `protobuf:"bytes,4,opt,name=CreateTime,proto3" json:"CreateTime,omitempty"` + IsBlock bool `protobuf:"varint,5,opt,name=IsBlock,proto3" json:"IsBlock,omitempty"` +} + +func (x *User) Reset() { + *x = User{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *User) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*User) ProtoMessage() {} + +func (x *User) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use User.ProtoReflect.Descriptor instead. +func (*User) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{21} +} + +func (x *User) GetProfilePhoto() string { + if x != nil { + return x.ProfilePhoto + } + return "" +} + +func (x *User) GetNickname() string { + if x != nil { + return x.Nickname + } + return "" +} + +func (x *User) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *User) GetCreateTime() string { + if x != nil { + return x.CreateTime + } + return "" +} + +func (x *User) GetIsBlock() bool { + if x != nil { + return x.IsBlock + } + return false +} + +type GetUserByIdResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` + User *User `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"` +} + +func (x *GetUserByIdResp) Reset() { + *x = GetUserByIdResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUserByIdResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUserByIdResp) ProtoMessage() {} + +func (x *GetUserByIdResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUserByIdResp.ProtoReflect.Descriptor instead. +func (*GetUserByIdResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{22} +} + +func (x *GetUserByIdResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +func (x *GetUserByIdResp) GetUser() *User { + if x != nil { + return x.User + } + return nil +} + +type GetUsersByNameReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserName string `protobuf:"bytes,1,opt,name=UserName,proto3" json:"UserName,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetUsersByNameReq) Reset() { + *x = GetUsersByNameReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUsersByNameReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUsersByNameReq) ProtoMessage() {} + +func (x *GetUsersByNameReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUsersByNameReq.ProtoReflect.Descriptor instead. +func (*GetUsersByNameReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{23} +} + +func (x *GetUsersByNameReq) GetUserName() string { + if x != nil { + return x.UserName + } + return "" +} + +func (x *GetUsersByNameReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetUsersByNameReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetUsersByNameResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Users []*User `protobuf:"bytes,1,rep,name=users,proto3" json:"users,omitempty"` + Pagination *sdk_ws.ResponsePagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + UserNums int32 `protobuf:"varint,3,opt,name=UserNums,proto3" json:"UserNums,omitempty"` +} + +func (x *GetUsersByNameResp) Reset() { + *x = GetUsersByNameResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUsersByNameResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUsersByNameResp) ProtoMessage() {} + +func (x *GetUsersByNameResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUsersByNameResp.ProtoReflect.Descriptor instead. +func (*GetUsersByNameResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{24} +} + +func (x *GetUsersByNameResp) GetUsers() []*User { + if x != nil { + return x.Users + } + return nil +} + +func (x *GetUsersByNameResp) GetPagination() *sdk_ws.ResponsePagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetUsersByNameResp) GetUserNums() int32 { + if x != nil { + return x.UserNums + } + return 0 +} + +type AlterUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=UserId,proto3" json:"UserId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` + PhoneNumber int64 `protobuf:"varint,3,opt,name=PhoneNumber,proto3" json:"PhoneNumber,omitempty"` + Nickname string `protobuf:"bytes,4,opt,name=Nickname,proto3" json:"Nickname,omitempty"` + Email string `protobuf:"bytes,5,opt,name=Email,proto3" json:"Email,omitempty"` +} + +func (x *AlterUserReq) Reset() { + *x = AlterUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AlterUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AlterUserReq) ProtoMessage() {} + +func (x *AlterUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[25] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AlterUserReq.ProtoReflect.Descriptor instead. +func (*AlterUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{25} +} + +func (x *AlterUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *AlterUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +func (x *AlterUserReq) GetPhoneNumber() int64 { + if x != nil { + return x.PhoneNumber + } + return 0 +} + +func (x *AlterUserReq) GetNickname() string { + if x != nil { + return x.Nickname + } + return "" +} + +func (x *AlterUserReq) GetEmail() string { + if x != nil { + return x.Email + } + return "" +} + +type AlterUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` +} + +func (x *AlterUserResp) Reset() { + *x = AlterUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AlterUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AlterUserResp) ProtoMessage() {} + +func (x *AlterUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AlterUserResp.ProtoReflect.Descriptor instead. +func (*AlterUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{26} +} + +func (x *AlterUserResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +type GetUsersReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OperationID string `protobuf:"bytes,1,opt,name=OperationID,proto3" json:"OperationID,omitempty"` + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,2,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + UserName string `protobuf:"bytes,3,opt,name=UserName,proto3" json:"UserName,omitempty"` +} + +func (x *GetUsersReq) Reset() { + *x = GetUsersReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUsersReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUsersReq) ProtoMessage() {} + +func (x *GetUsersReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[27] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUsersReq.ProtoReflect.Descriptor instead. +func (*GetUsersReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{27} +} + +func (x *GetUsersReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +func (x *GetUsersReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetUsersReq) GetUserName() string { + if x != nil { + return x.UserName + } + return "" +} + +type GetUsersResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` + User []*User `protobuf:"bytes,2,rep,name=user,proto3" json:"user,omitempty"` + Pagination *sdk_ws.ResponsePagination `protobuf:"bytes,3,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + UserNums int32 `protobuf:"varint,4,opt,name=UserNums,proto3" json:"UserNums,omitempty"` +} + +func (x *GetUsersResp) Reset() { + *x = GetUsersResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetUsersResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetUsersResp) ProtoMessage() {} + +func (x *GetUsersResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[28] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetUsersResp.ProtoReflect.Descriptor instead. +func (*GetUsersResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{28} +} + +func (x *GetUsersResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +func (x *GetUsersResp) GetUser() []*User { + if x != nil { + return x.User + } + return nil +} + +func (x *GetUsersResp) GetPagination() *sdk_ws.ResponsePagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetUsersResp) GetUserNums() int32 { + if x != nil { + return x.UserNums + } + return 0 +} + +type AddUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OperationID string `protobuf:"bytes,1,opt,name=OperationID,proto3" json:"OperationID,omitempty"` + PhoneNumber string `protobuf:"bytes,2,opt,name=PhoneNumber,proto3" json:"PhoneNumber,omitempty"` + UserId string `protobuf:"bytes,3,opt,name=UserId,proto3" json:"UserId,omitempty"` + Name string `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"` +} + +func (x *AddUserReq) Reset() { + *x = AddUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddUserReq) ProtoMessage() {} + +func (x *AddUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[29] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddUserReq.ProtoReflect.Descriptor instead. +func (*AddUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{29} +} + +func (x *AddUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +func (x *AddUserReq) GetPhoneNumber() string { + if x != nil { + return x.PhoneNumber + } + return "" +} + +func (x *AddUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *AddUserReq) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type AddUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` +} + +func (x *AddUserResp) Reset() { + *x = AddUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AddUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AddUserResp) ProtoMessage() {} + +func (x *AddUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[30] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AddUserResp.ProtoReflect.Descriptor instead. +func (*AddUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{30} +} + +func (x *AddUserResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +type BlockUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=UserId,proto3" json:"UserId,omitempty"` + EndDisableTime string `protobuf:"bytes,2,opt,name=EndDisableTime,proto3" json:"EndDisableTime,omitempty"` + OperationID string `protobuf:"bytes,3,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *BlockUserReq) Reset() { + *x = BlockUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlockUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockUserReq) ProtoMessage() {} + +func (x *BlockUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[31] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockUserReq.ProtoReflect.Descriptor instead. +func (*BlockUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{31} +} + +func (x *BlockUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *BlockUserReq) GetEndDisableTime() string { + if x != nil { + return x.EndDisableTime + } + return "" +} + +func (x *BlockUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type BlockUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` +} + +func (x *BlockUserResp) Reset() { + *x = BlockUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlockUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockUserResp) ProtoMessage() {} + +func (x *BlockUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[32] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockUserResp.ProtoReflect.Descriptor instead. +func (*BlockUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{32} +} + +func (x *BlockUserResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +type UnBlockUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=UserId,proto3" json:"UserId,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *UnBlockUserReq) Reset() { + *x = UnBlockUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnBlockUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnBlockUserReq) ProtoMessage() {} + +func (x *UnBlockUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[33] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnBlockUserReq.ProtoReflect.Descriptor instead. +func (*UnBlockUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{33} +} + +func (x *UnBlockUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *UnBlockUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type UnBlockUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` +} + +func (x *UnBlockUserResp) Reset() { + *x = UnBlockUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UnBlockUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnBlockUserResp) ProtoMessage() {} + +func (x *UnBlockUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[34] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UnBlockUserResp.ProtoReflect.Descriptor instead. +func (*UnBlockUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{34} +} + +func (x *UnBlockUserResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +type GetBlockUsersReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Pagination *sdk_ws.RequestPagination `protobuf:"bytes,1,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` + BlockUserNum int32 `protobuf:"varint,3,opt,name=BlockUserNum,proto3" json:"BlockUserNum,omitempty"` +} + +func (x *GetBlockUsersReq) Reset() { + *x = GetBlockUsersReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetBlockUsersReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockUsersReq) ProtoMessage() {} + +func (x *GetBlockUsersReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[35] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockUsersReq.ProtoReflect.Descriptor instead. +func (*GetBlockUsersReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{35} +} + +func (x *GetBlockUsersReq) GetPagination() *sdk_ws.RequestPagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetBlockUsersReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +func (x *GetBlockUsersReq) GetBlockUserNum() int32 { + if x != nil { + return x.BlockUserNum + } + return 0 +} + +type BlockUser struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + User *User `protobuf:"bytes,1,opt,name=User,proto3" json:"User,omitempty"` + BeginDisableTime string `protobuf:"bytes,2,opt,name=BeginDisableTime,proto3" json:"BeginDisableTime,omitempty"` + EndDisableTime string `protobuf:"bytes,3,opt,name=EndDisableTime,proto3" json:"EndDisableTime,omitempty"` +} + +func (x *BlockUser) Reset() { + *x = BlockUser{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[36] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BlockUser) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockUser) ProtoMessage() {} + +func (x *BlockUser) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[36] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockUser.ProtoReflect.Descriptor instead. +func (*BlockUser) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{36} +} + +func (x *BlockUser) GetUser() *User { + if x != nil { + return x.User + } + return nil +} + +func (x *BlockUser) GetBeginDisableTime() string { + if x != nil { + return x.BeginDisableTime + } + return "" +} + +func (x *BlockUser) GetEndDisableTime() string { + if x != nil { + return x.EndDisableTime + } + return "" +} + +type GetBlockUsersResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + CommonResp *CommonResp `protobuf:"bytes,1,opt,name=CommonResp,proto3" json:"CommonResp,omitempty"` + BlockUsers []*BlockUser `protobuf:"bytes,2,rep,name=BlockUsers,proto3" json:"BlockUsers,omitempty"` + Pagination *sdk_ws.ResponsePagination `protobuf:"bytes,3,opt,name=Pagination,proto3" json:"Pagination,omitempty"` + UserNums int32 `protobuf:"varint,4,opt,name=UserNums,proto3" json:"UserNums,omitempty"` +} + +func (x *GetBlockUsersResp) Reset() { + *x = GetBlockUsersResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[37] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetBlockUsersResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockUsersResp) ProtoMessage() {} + +func (x *GetBlockUsersResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[37] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockUsersResp.ProtoReflect.Descriptor instead. +func (*GetBlockUsersResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{37} +} + +func (x *GetBlockUsersResp) GetCommonResp() *CommonResp { + if x != nil { + return x.CommonResp + } + return nil +} + +func (x *GetBlockUsersResp) GetBlockUsers() []*BlockUser { + if x != nil { + return x.BlockUsers + } + return nil +} + +func (x *GetBlockUsersResp) GetPagination() *sdk_ws.ResponsePagination { + if x != nil { + return x.Pagination + } + return nil +} + +func (x *GetBlockUsersResp) GetUserNums() int32 { + if x != nil { + return x.UserNums + } + return 0 +} + +type GetBlockUserByIdReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=User_id,json=UserId,proto3" json:"User_id,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *GetBlockUserByIdReq) Reset() { + *x = GetBlockUserByIdReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetBlockUserByIdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockUserByIdReq) ProtoMessage() {} + +func (x *GetBlockUserByIdReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockUserByIdReq.ProtoReflect.Descriptor instead. +func (*GetBlockUserByIdReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{38} +} + +func (x *GetBlockUserByIdReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *GetBlockUserByIdReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type GetBlockUserByIdResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BlockUser *BlockUser `protobuf:"bytes,2,opt,name=BlockUser,proto3" json:"BlockUser,omitempty"` +} + +func (x *GetBlockUserByIdResp) Reset() { + *x = GetBlockUserByIdResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[39] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetBlockUserByIdResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBlockUserByIdResp) ProtoMessage() {} + +func (x *GetBlockUserByIdResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[39] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBlockUserByIdResp.ProtoReflect.Descriptor instead. +func (*GetBlockUserByIdResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{39} +} + +func (x *GetBlockUserByIdResp) GetBlockUser() *BlockUser { + if x != nil { + return x.BlockUser + } + return nil +} + +type DeleteUserReq struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserId string `protobuf:"bytes,1,opt,name=User_id,json=UserId,proto3" json:"User_id,omitempty"` + OperationID string `protobuf:"bytes,2,opt,name=OperationID,proto3" json:"OperationID,omitempty"` +} + +func (x *DeleteUserReq) Reset() { + *x = DeleteUserReq{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteUserReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteUserReq) ProtoMessage() {} + +func (x *DeleteUserReq) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[40] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteUserReq.ProtoReflect.Descriptor instead. +func (*DeleteUserReq) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{40} +} + +func (x *DeleteUserReq) GetUserId() string { + if x != nil { + return x.UserId + } + return "" +} + +func (x *DeleteUserReq) GetOperationID() string { + if x != nil { + return x.OperationID + } + return "" +} + +type DeleteUserResp struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *DeleteUserResp) Reset() { + *x = DeleteUserResp{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[41] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *DeleteUserResp) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteUserResp) ProtoMessage() {} + +func (x *DeleteUserResp) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[41] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteUserResp.ProtoReflect.Descriptor instead. +func (*DeleteUserResp) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{41} +} + +type AccountCheckResp_SingleUserStatus struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + UserID string `protobuf:"bytes,1,opt,name=userID,proto3" json:"userID,omitempty"` + AccountStatus string `protobuf:"bytes,2,opt,name=accountStatus,proto3" json:"accountStatus,omitempty"` +} + +func (x *AccountCheckResp_SingleUserStatus) Reset() { + *x = AccountCheckResp_SingleUserStatus{} + if protoimpl.UnsafeEnabled { + mi := &file_user_user_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AccountCheckResp_SingleUserStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AccountCheckResp_SingleUserStatus) ProtoMessage() {} + +func (x *AccountCheckResp_SingleUserStatus) ProtoReflect() protoreflect.Message { + mi := &file_user_user_proto_msgTypes[42] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AccountCheckResp_SingleUserStatus.ProtoReflect.Descriptor instead. +func (*AccountCheckResp_SingleUserStatus) Descriptor() ([]byte, []int) { + return file_user_user_proto_rawDescGZIP(), []int{6, 0} +} + +func (x *AccountCheckResp_SingleUserStatus) GetUserID() string { + if x != nil { + return x.UserID + } + return "" +} + +func (x *AccountCheckResp_SingleUserStatus) GetAccountStatus() string { + if x != nil { + return x.AccountStatus + } + return "" +} + +var File_user_user_proto protoreflect.FileDescriptor + +var file_user_user_proto_rawDesc = []byte{ + 0x0a, 0x0f, 0x75, 0x73, 0x65, 0x72, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x12, 0x04, 0x75, 0x73, 0x65, 0x72, 0x1a, 0x21, 0x4f, 0x70, 0x65, 0x6e, 0x5f, 0x49, 0x4d, + 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x73, 0x64, 0x6b, 0x5f, 0x77, + 0x73, 0x2f, 0x77, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x3e, 0x0a, 0x0a, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x65, 0x72, 0x72, 0x43, + 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x65, 0x72, 0x72, 0x43, 0x6f, + 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x65, 0x72, 0x72, 0x4d, 0x73, 0x67, 0x22, 0x7a, 0x0a, 0x0e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x12, 0x2a, 0x0a, 0x10, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x4f, 0x70, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4f, 0x70, 0x55, 0x73, + 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x6f, 0x0a, 0x0f, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, + 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, + 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x2a, 0x0a, 0x10, 0x46, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x10, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x4f, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x41, 0x6c, + 0x6c, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x65, 0x71, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6f, 0x70, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x64, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x41, + 0x6c, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x1e, + 0x0a, 0x0a, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x0a, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x79, + 0x0a, 0x0f, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, + 0x71, 0x12, 0x28, 0x0a, 0x0f, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, + 0x4c, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0f, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x4f, + 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4f, + 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xdf, 0x01, 0x0a, 0x10, 0x41, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, + 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x12, 0x47, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x41, 0x63, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x2e, 0x53, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0a, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x1a, 0x50, 0x0a, 0x10, 0x53, 0x69, 0x6e, + 0x67, 0x6c, 0x65, 0x55, 0x73, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, + 0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x24, 0x0a, 0x0d, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x63, + 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x6e, 0x0a, 0x0e, 0x47, + 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x12, 0x1e, 0x0a, + 0x0a, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x0a, 0x75, 0x73, 0x65, 0x72, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x84, 0x01, 0x0a, 0x0f, + 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x30, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x3f, 0x0a, 0x0c, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, 0x73, + 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, + 0x73, 0x74, 0x22, 0x8a, 0x01, 0x0a, 0x11, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x12, 0x37, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x12, 0x1a, 0x0a, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, + 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, + 0x46, 0x0a, 0x12, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x22, 0xb9, 0x01, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x52, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, + 0x52, 0x65, 0x71, 0x12, 0x1e, 0x0a, 0x0a, 0x46, 0x72, 0x6f, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x46, 0x72, 0x6f, 0x6d, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x70, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x03, 0x6f, 0x70, 0x74, 0x12, 0x2e, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x09, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x22, 0x4b, 0x0a, 0x09, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, + 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x22, 0x9b, 0x01, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, + 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x4d, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, + 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x52, 0x19, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x22, 0xa7, + 0x01, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x71, 0x12, 0x1e, 0x0a, 0x0a, 0x46, 0x72, + 0x6f, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x46, 0x72, 0x6f, 0x6d, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x2e, 0x0a, 0x12, 0x63, 0x6f, + 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x70, + 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, + 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x4f, 0x70, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x22, 0x9b, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, + 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4d, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x76, 0x65, + 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x4c, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x65, + 0x72, 0x2e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x19, 0x63, 0x6f, 0x6e, + 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, + 0x6c, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x7b, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, + 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x4f, + 0x70, 0x74, 0x52, 0x65, 0x71, 0x12, 0x1e, 0x0a, 0x0a, 0x46, 0x72, 0x6f, 0x6d, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x46, 0x72, 0x6f, 0x6d, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4f, 0x70, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x44, 0x22, 0x9f, 0x01, 0x0a, 0x1c, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x43, 0x6f, + 0x6e, 0x76, 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x4f, 0x70, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x4d, 0x0a, 0x19, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x72, + 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x4c, + 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x19, 0x63, 0x6f, 0x6e, 0x76, + 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x49, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x20, + 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x22, 0x42, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x22, 0x4a, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x42, + 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x20, + 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x22, 0x98, 0x01, 0x0a, 0x04, 0x55, 0x73, 0x65, 0x72, 0x12, 0x22, 0x0a, 0x0c, 0x50, 0x72, 0x6f, + 0x66, 0x69, 0x6c, 0x65, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x50, 0x68, 0x6f, 0x74, 0x6f, 0x12, 0x1a, 0x0a, + 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, + 0x72, 0x49, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x49, 0x73, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x07, 0x49, 0x73, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x63, 0x0a, 0x0f, 0x47, + 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, + 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, + 0x12, 0x1e, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0a, + 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, + 0x22, 0x97, 0x01, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x42, 0x79, 0x4e, + 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, + 0x6d, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, + 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x99, 0x01, 0x0a, 0x12, 0x47, + 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x20, 0x0a, 0x05, 0x75, 0x73, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x0a, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x05, 0x75, 0x73, + 0x65, 0x72, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, + 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, + 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x55, 0x73, + 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x22, 0x9c, 0x01, 0x0a, 0x0c, 0x41, 0x6c, 0x74, 0x65, 0x72, + 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, + 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, 0x6d, + 0x62, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x4e, 0x69, 0x63, 0x6b, 0x6e, 0x61, 0x6d, 0x65, 0x12, + 0x14, 0x0a, 0x05, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x22, 0x41, 0x0a, 0x0d, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x55, 0x73, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, + 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x22, 0x91, 0x01, 0x0a, 0x0b, 0x47, 0x65, 0x74, + 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x44, 0x0a, 0x0a, 0x50, 0x61, + 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, + 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, + 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0xc3, 0x01, 0x0a, + 0x0c, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, + 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x1e, 0x0a, 0x04, 0x75, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0a, 0x2e, + 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, + 0x45, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, + 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, + 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, + 0x6d, 0x73, 0x22, 0x7c, 0x0a, 0x0a, 0x41, 0x64, 0x64, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, + 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x50, 0x68, 0x6f, 0x6e, 0x65, 0x4e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0x3f, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x22, 0x70, 0x0a, 0x0c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x0e, 0x45, 0x6e, 0x64, + 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0e, 0x45, 0x6e, 0x64, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x22, 0x41, 0x0a, 0x0d, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, + 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, + 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x22, 0x4a, 0x0a, 0x0e, 0x55, 0x6e, 0x42, 0x6c, 0x6f, 0x63, + 0x6b, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, 0x16, 0x0a, 0x06, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, + 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x22, 0x43, 0x0a, 0x0f, 0x55, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, + 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, + 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x12, 0x44, 0x0a, 0x0a, + 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x24, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, + 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x50, 0x61, 0x67, 0x69, + 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, + 0x72, 0x4e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x42, 0x6c, 0x6f, 0x63, + 0x6b, 0x55, 0x73, 0x65, 0x72, 0x4e, 0x75, 0x6d, 0x22, 0x7f, 0x0a, 0x09, 0x42, 0x6c, 0x6f, 0x63, + 0x6b, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1e, 0x0a, 0x04, 0x55, 0x73, 0x65, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x0a, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x04, 0x55, 0x73, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x10, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x44, 0x69, + 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x10, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x26, 0x0a, 0x0e, 0x45, 0x6e, 0x64, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, + 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x45, 0x6e, 0x64, 0x44, 0x69, + 0x73, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x22, 0xd9, 0x01, 0x0a, 0x11, 0x47, 0x65, + 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x30, 0x0a, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x52, 0x0a, 0x43, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x2f, 0x0a, 0x0a, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x52, 0x0a, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, + 0x72, 0x73, 0x12, 0x45, 0x0a, 0x0a, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, + 0x61, 0x70, 0x69, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x50, 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x50, + 0x61, 0x67, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x55, 0x73, 0x65, + 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x55, 0x73, 0x65, + 0x72, 0x4e, 0x75, 0x6d, 0x73, 0x22, 0x50, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, + 0x6b, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x12, 0x17, 0x0a, 0x07, + 0x55, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x45, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x42, 0x6c, + 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x2d, 0x0a, 0x09, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x09, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x22, 0x4a, + 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x12, + 0x17, 0x0a, 0x07, 0x55, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x55, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x70, 0x65, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0x10, 0x0a, 0x0e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x32, 0xdd, 0x09, 0x0a, + 0x04, 0x75, 0x73, 0x65, 0x72, 0x12, 0x3a, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, + 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x15, 0x2e, 0x75, 0x73, 0x65, + 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x43, 0x0a, 0x0e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x49, + 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x75, + 0x73, 0x65, 0x72, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x12, 0x3a, 0x0a, 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, + 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x1a, 0x15, 0x2e, 0x75, 0x73, + 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x3d, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x55, 0x73, 0x65, 0x72, + 0x49, 0x44, 0x12, 0x15, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, + 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x65, 0x71, 0x1a, 0x16, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x55, 0x73, 0x65, 0x72, 0x49, 0x44, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x55, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x12, 0x1d, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x1e, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, + 0x53, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x55, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x52, + 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, + 0x12, 0x1d, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x71, 0x1a, + 0x1e, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, + 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, + 0x61, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x4f, 0x70, 0x74, 0x12, 0x21, 0x2e, 0x75, 0x73, + 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6e, 0x76, 0x65, 0x72, 0x73, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x4f, 0x70, 0x74, 0x52, 0x65, 0x71, 0x1a, 0x22, + 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x6c, 0x6c, 0x43, 0x6f, 0x6e, 0x76, + 0x65, 0x72, 0x73, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x73, 0x67, 0x4f, 0x70, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x3d, 0x0a, 0x0c, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x68, 0x65, + 0x63, 0x6b, 0x12, 0x15, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x1a, 0x16, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x41, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x3a, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, + 0x12, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x42, + 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x15, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, + 0x74, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x73, 0x70, 0x12, 0x43, 0x0a, + 0x0e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x17, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x42, + 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, + 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x42, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x12, 0x37, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x55, 0x73, 0x65, 0x72, + 0x12, 0x13, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x73, 0x69, 0x67, 0x6e, 0x55, 0x73, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x52, 0x65, 0x73, + 0x69, 0x67, 0x6e, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x34, 0x0a, 0x09, 0x41, + 0x6c, 0x74, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x12, 0x12, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, + 0x41, 0x6c, 0x74, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x13, 0x2e, 0x75, + 0x73, 0x65, 0x72, 0x2e, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, + 0x70, 0x12, 0x31, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x11, 0x2e, + 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, + 0x1a, 0x12, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x55, 0x73, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x2e, 0x0a, 0x07, 0x41, 0x64, 0x64, 0x55, 0x73, 0x65, 0x72, 0x12, + 0x10, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x41, 0x64, 0x64, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, + 0x71, 0x1a, 0x11, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x41, 0x64, 0x64, 0x55, 0x73, 0x65, 0x72, + 0x52, 0x65, 0x73, 0x70, 0x12, 0x34, 0x0a, 0x09, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, + 0x72, 0x12, 0x12, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, + 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x13, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x3a, 0x0a, 0x0b, 0x55, 0x6e, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x12, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, + 0x2e, 0x55, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, + 0x15, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x55, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, + 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x12, 0x40, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, + 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, + 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x1a, + 0x17, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, + 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x12, 0x49, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x12, 0x19, 0x2e, 0x75, + 0x73, 0x65, 0x72, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, + 0x42, 0x79, 0x49, 0x64, 0x52, 0x65, 0x71, 0x1a, 0x1a, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x47, + 0x65, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x55, 0x73, 0x65, 0x72, 0x42, 0x79, 0x49, 0x64, 0x52, + 0x65, 0x73, 0x70, 0x12, 0x37, 0x0a, 0x0a, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, + 0x72, 0x12, 0x13, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x55, + 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x1a, 0x14, 0x2e, 0x75, 0x73, 0x65, 0x72, 0x2e, 0x44, 0x65, + 0x6c, 0x65, 0x74, 0x65, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x42, 0x0d, 0x5a, 0x0b, + 0x2e, 0x2f, 0x75, 0x73, 0x65, 0x72, 0x3b, 0x75, 0x73, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, +} + +var ( + file_user_user_proto_rawDescOnce sync.Once + file_user_user_proto_rawDescData = file_user_user_proto_rawDesc +) + +func file_user_user_proto_rawDescGZIP() []byte { + file_user_user_proto_rawDescOnce.Do(func() { + file_user_user_proto_rawDescData = protoimpl.X.CompressGZIP(file_user_user_proto_rawDescData) + }) + return file_user_user_proto_rawDescData +} + +var file_user_user_proto_msgTypes = make([]protoimpl.MessageInfo, 43) +var file_user_user_proto_goTypes = []interface{}{ + (*CommonResp)(nil), // 0: user.CommonResp + (*DeleteUsersReq)(nil), // 1: user.DeleteUsersReq + (*DeleteUsersResp)(nil), // 2: user.DeleteUsersResp + (*GetAllUserIDReq)(nil), // 3: user.GetAllUserIDReq + (*GetAllUserIDResp)(nil), // 4: user.GetAllUserIDResp + (*AccountCheckReq)(nil), // 5: user.AccountCheckReq + (*AccountCheckResp)(nil), // 6: user.AccountCheckResp + (*GetUserInfoReq)(nil), // 7: user.GetUserInfoReq + (*GetUserInfoResp)(nil), // 8: user.GetUserInfoResp + (*UpdateUserInfoReq)(nil), // 9: user.UpdateUserInfoReq + (*UpdateUserInfoResp)(nil), // 10: user.UpdateUserInfoResp + (*SetReceiveMessageOptReq)(nil), // 11: user.SetReceiveMessageOptReq + (*OptResult)(nil), // 12: user.OptResult + (*SetReceiveMessageOptResp)(nil), // 13: user.SetReceiveMessageOptResp + (*GetReceiveMessageOptReq)(nil), // 14: user.GetReceiveMessageOptReq + (*GetReceiveMessageOptResp)(nil), // 15: user.GetReceiveMessageOptResp + (*GetAllConversationMsgOptReq)(nil), // 16: user.GetAllConversationMsgOptReq + (*GetAllConversationMsgOptResp)(nil), // 17: user.GetAllConversationMsgOptResp + (*ResignUserReq)(nil), // 18: user.ResignUserReq + (*ResignUserResp)(nil), // 19: user.ResignUserResp + (*GetUserByIdReq)(nil), // 20: user.GetUserByIdReq + (*User)(nil), // 21: user.User + (*GetUserByIdResp)(nil), // 22: user.GetUserByIdResp + (*GetUsersByNameReq)(nil), // 23: user.GetUsersByNameReq + (*GetUsersByNameResp)(nil), // 24: user.GetUsersByNameResp + (*AlterUserReq)(nil), // 25: user.AlterUserReq + (*AlterUserResp)(nil), // 26: user.AlterUserResp + (*GetUsersReq)(nil), // 27: user.GetUsersReq + (*GetUsersResp)(nil), // 28: user.GetUsersResp + (*AddUserReq)(nil), // 29: user.AddUserReq + (*AddUserResp)(nil), // 30: user.AddUserResp + (*BlockUserReq)(nil), // 31: user.BlockUserReq + (*BlockUserResp)(nil), // 32: user.BlockUserResp + (*UnBlockUserReq)(nil), // 33: user.UnBlockUserReq + (*UnBlockUserResp)(nil), // 34: user.UnBlockUserResp + (*GetBlockUsersReq)(nil), // 35: user.GetBlockUsersReq + (*BlockUser)(nil), // 36: user.BlockUser + (*GetBlockUsersResp)(nil), // 37: user.GetBlockUsersResp + (*GetBlockUserByIdReq)(nil), // 38: user.GetBlockUserByIdReq + (*GetBlockUserByIdResp)(nil), // 39: user.GetBlockUserByIdResp + (*DeleteUserReq)(nil), // 40: user.DeleteUserReq + (*DeleteUserResp)(nil), // 41: user.DeleteUserResp + (*AccountCheckResp_SingleUserStatus)(nil), // 42: user.AccountCheckResp.SingleUserStatus + (*sdk_ws.UserInfo)(nil), // 43: server_api_params.UserInfo + (*sdk_ws.RequestPagination)(nil), // 44: server_api_params.RequestPagination + (*sdk_ws.ResponsePagination)(nil), // 45: server_api_params.ResponsePagination +} +var file_user_user_proto_depIdxs = []int32{ + 0, // 0: user.DeleteUsersResp.CommonResp:type_name -> user.CommonResp + 0, // 1: user.GetAllUserIDResp.CommonResp:type_name -> user.CommonResp + 0, // 2: user.AccountCheckResp.commonResp:type_name -> user.CommonResp + 42, // 3: user.AccountCheckResp.ResultList:type_name -> user.AccountCheckResp.SingleUserStatus + 0, // 4: user.GetUserInfoResp.commonResp:type_name -> user.CommonResp + 43, // 5: user.GetUserInfoResp.UserInfoList:type_name -> server_api_params.UserInfo + 43, // 6: user.UpdateUserInfoReq.UserInfo:type_name -> server_api_params.UserInfo + 0, // 7: user.UpdateUserInfoResp.commonResp:type_name -> user.CommonResp + 0, // 8: user.SetReceiveMessageOptResp.commonResp:type_name -> user.CommonResp + 12, // 9: user.SetReceiveMessageOptResp.conversationOptResultList:type_name -> user.OptResult + 0, // 10: user.GetReceiveMessageOptResp.commonResp:type_name -> user.CommonResp + 12, // 11: user.GetReceiveMessageOptResp.conversationOptResultList:type_name -> user.OptResult + 0, // 12: user.GetAllConversationMsgOptResp.commonResp:type_name -> user.CommonResp + 12, // 13: user.GetAllConversationMsgOptResp.conversationOptResultList:type_name -> user.OptResult + 0, // 14: user.ResignUserResp.commonResp:type_name -> user.CommonResp + 0, // 15: user.GetUserByIdResp.CommonResp:type_name -> user.CommonResp + 21, // 16: user.GetUserByIdResp.user:type_name -> user.User + 44, // 17: user.GetUsersByNameReq.Pagination:type_name -> server_api_params.RequestPagination + 21, // 18: user.GetUsersByNameResp.users:type_name -> user.User + 45, // 19: user.GetUsersByNameResp.Pagination:type_name -> server_api_params.ResponsePagination + 0, // 20: user.AlterUserResp.CommonResp:type_name -> user.CommonResp + 44, // 21: user.GetUsersReq.Pagination:type_name -> server_api_params.RequestPagination + 0, // 22: user.GetUsersResp.CommonResp:type_name -> user.CommonResp + 21, // 23: user.GetUsersResp.user:type_name -> user.User + 45, // 24: user.GetUsersResp.Pagination:type_name -> server_api_params.ResponsePagination + 0, // 25: user.AddUserResp.CommonResp:type_name -> user.CommonResp + 0, // 26: user.BlockUserResp.CommonResp:type_name -> user.CommonResp + 0, // 27: user.UnBlockUserResp.CommonResp:type_name -> user.CommonResp + 44, // 28: user.GetBlockUsersReq.Pagination:type_name -> server_api_params.RequestPagination + 21, // 29: user.BlockUser.User:type_name -> user.User + 0, // 30: user.GetBlockUsersResp.CommonResp:type_name -> user.CommonResp + 36, // 31: user.GetBlockUsersResp.BlockUsers:type_name -> user.BlockUser + 45, // 32: user.GetBlockUsersResp.Pagination:type_name -> server_api_params.ResponsePagination + 36, // 33: user.GetBlockUserByIdResp.BlockUser:type_name -> user.BlockUser + 7, // 34: user.user.GetUserInfo:input_type -> user.GetUserInfoReq + 9, // 35: user.user.UpdateUserInfo:input_type -> user.UpdateUserInfoReq + 1, // 36: user.user.DeleteUsers:input_type -> user.DeleteUsersReq + 3, // 37: user.user.GetAllUserID:input_type -> user.GetAllUserIDReq + 11, // 38: user.user.SetReceiveMessageOpt:input_type -> user.SetReceiveMessageOptReq + 14, // 39: user.user.GetReceiveMessageOpt:input_type -> user.GetReceiveMessageOptReq + 16, // 40: user.user.GetAllConversationMsgOpt:input_type -> user.GetAllConversationMsgOptReq + 5, // 41: user.user.AccountCheck:input_type -> user.AccountCheckReq + 20, // 42: user.user.GetUserById:input_type -> user.GetUserByIdReq + 23, // 43: user.user.GetUsersByName:input_type -> user.GetUsersByNameReq + 18, // 44: user.user.ResignUser:input_type -> user.ResignUserReq + 25, // 45: user.user.AlterUser:input_type -> user.AlterUserReq + 27, // 46: user.user.GetUsers:input_type -> user.GetUsersReq + 29, // 47: user.user.AddUser:input_type -> user.AddUserReq + 31, // 48: user.user.BlockUser:input_type -> user.BlockUserReq + 33, // 49: user.user.UnBlockUser:input_type -> user.UnBlockUserReq + 35, // 50: user.user.GetBlockUsers:input_type -> user.GetBlockUsersReq + 38, // 51: user.user.GetBlockUserById:input_type -> user.GetBlockUserByIdReq + 40, // 52: user.user.DeleteUser:input_type -> user.DeleteUserReq + 8, // 53: user.user.GetUserInfo:output_type -> user.GetUserInfoResp + 10, // 54: user.user.UpdateUserInfo:output_type -> user.UpdateUserInfoResp + 2, // 55: user.user.DeleteUsers:output_type -> user.DeleteUsersResp + 4, // 56: user.user.GetAllUserID:output_type -> user.GetAllUserIDResp + 13, // 57: user.user.SetReceiveMessageOpt:output_type -> user.SetReceiveMessageOptResp + 15, // 58: user.user.GetReceiveMessageOpt:output_type -> user.GetReceiveMessageOptResp + 17, // 59: user.user.GetAllConversationMsgOpt:output_type -> user.GetAllConversationMsgOptResp + 6, // 60: user.user.AccountCheck:output_type -> user.AccountCheckResp + 22, // 61: user.user.GetUserById:output_type -> user.GetUserByIdResp + 24, // 62: user.user.GetUsersByName:output_type -> user.GetUsersByNameResp + 19, // 63: user.user.ResignUser:output_type -> user.ResignUserResp + 26, // 64: user.user.AlterUser:output_type -> user.AlterUserResp + 28, // 65: user.user.GetUsers:output_type -> user.GetUsersResp + 30, // 66: user.user.AddUser:output_type -> user.AddUserResp + 32, // 67: user.user.BlockUser:output_type -> user.BlockUserResp + 34, // 68: user.user.UnBlockUser:output_type -> user.UnBlockUserResp + 37, // 69: user.user.GetBlockUsers:output_type -> user.GetBlockUsersResp + 39, // 70: user.user.GetBlockUserById:output_type -> user.GetBlockUserByIdResp + 41, // 71: user.user.DeleteUser:output_type -> user.DeleteUserResp + 53, // [53:72] is the sub-list for method output_type + 34, // [34:53] is the sub-list for method input_type + 34, // [34:34] is the sub-list for extension type_name + 34, // [34:34] is the sub-list for extension extendee + 0, // [0:34] is the sub-list for field type_name +} + +func init() { file_user_user_proto_init() } +func file_user_user_proto_init() { + if File_user_user_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_user_user_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommonResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteUsersReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteUsersResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllUserIDReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllUserIDResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AccountCheckReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AccountCheckResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserInfoReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserInfoResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateUserInfoReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateUserInfoResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetReceiveMessageOptReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*OptResult); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*SetReceiveMessageOptResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetReceiveMessageOptReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetReceiveMessageOptResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllConversationMsgOptReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetAllConversationMsgOptResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResignUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ResignUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserByIdReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*User); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUserByIdResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUsersByNameReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUsersByNameResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AlterUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AlterUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUsersReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetUsersResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AddUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlockUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlockUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UnBlockUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UnBlockUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetBlockUsersReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BlockUser); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetBlockUsersResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetBlockUserByIdReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetBlockUserByIdResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteUserReq); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*DeleteUserResp); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_user_user_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AccountCheckResp_SingleUserStatus); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_user_user_proto_rawDesc, + NumEnums: 0, + NumMessages: 43, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_user_user_proto_goTypes, + DependencyIndexes: file_user_user_proto_depIdxs, + MessageInfos: file_user_user_proto_msgTypes, + }.Build() + File_user_user_proto = out.File + file_user_user_proto_rawDesc = nil + file_user_user_proto_goTypes = nil + file_user_user_proto_depIdxs = nil } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context -var _ grpc.ClientConn +var _ grpc.ClientConnInterface // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 - -// Client API for User service +const _ = grpc.SupportPackageIsVersion6 +// UserClient is the client API for User service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type UserClient interface { GetUserInfo(ctx context.Context, in *GetUserInfoReq, opts ...grpc.CallOption) (*GetUserInfoResp, error) UpdateUserInfo(ctx context.Context, in *UpdateUserInfoReq, opts ...grpc.CallOption) (*UpdateUserInfoResp, error) @@ -1011,19 +3644,30 @@ type UserClient interface { GetReceiveMessageOpt(ctx context.Context, in *GetReceiveMessageOptReq, opts ...grpc.CallOption) (*GetReceiveMessageOptResp, error) GetAllConversationMsgOpt(ctx context.Context, in *GetAllConversationMsgOptReq, opts ...grpc.CallOption) (*GetAllConversationMsgOptResp, error) AccountCheck(ctx context.Context, in *AccountCheckReq, opts ...grpc.CallOption) (*AccountCheckResp, error) + GetUserById(ctx context.Context, in *GetUserByIdReq, opts ...grpc.CallOption) (*GetUserByIdResp, error) + GetUsersByName(ctx context.Context, in *GetUsersByNameReq, opts ...grpc.CallOption) (*GetUsersByNameResp, error) + ResignUser(ctx context.Context, in *ResignUserReq, opts ...grpc.CallOption) (*ResignUserResp, error) + AlterUser(ctx context.Context, in *AlterUserReq, opts ...grpc.CallOption) (*AlterUserResp, error) + GetUsers(ctx context.Context, in *GetUsersReq, opts ...grpc.CallOption) (*GetUsersResp, error) + AddUser(ctx context.Context, in *AddUserReq, opts ...grpc.CallOption) (*AddUserResp, error) + BlockUser(ctx context.Context, in *BlockUserReq, opts ...grpc.CallOption) (*BlockUserResp, error) + UnBlockUser(ctx context.Context, in *UnBlockUserReq, opts ...grpc.CallOption) (*UnBlockUserResp, error) + GetBlockUsers(ctx context.Context, in *GetBlockUsersReq, opts ...grpc.CallOption) (*GetBlockUsersResp, error) + GetBlockUserById(ctx context.Context, in *GetBlockUserByIdReq, opts ...grpc.CallOption) (*GetBlockUserByIdResp, error) + DeleteUser(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserResp, error) } type userClient struct { - cc *grpc.ClientConn + cc grpc.ClientConnInterface } -func NewUserClient(cc *grpc.ClientConn) UserClient { +func NewUserClient(cc grpc.ClientConnInterface) UserClient { return &userClient{cc} } func (c *userClient) GetUserInfo(ctx context.Context, in *GetUserInfoReq, opts ...grpc.CallOption) (*GetUserInfoResp, error) { out := new(GetUserInfoResp) - err := grpc.Invoke(ctx, "/user.user/GetUserInfo", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/GetUserInfo", in, out, opts...) if err != nil { return nil, err } @@ -1032,7 +3676,7 @@ func (c *userClient) GetUserInfo(ctx context.Context, in *GetUserInfoReq, opts . func (c *userClient) UpdateUserInfo(ctx context.Context, in *UpdateUserInfoReq, opts ...grpc.CallOption) (*UpdateUserInfoResp, error) { out := new(UpdateUserInfoResp) - err := grpc.Invoke(ctx, "/user.user/UpdateUserInfo", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/UpdateUserInfo", in, out, opts...) if err != nil { return nil, err } @@ -1041,7 +3685,7 @@ func (c *userClient) UpdateUserInfo(ctx context.Context, in *UpdateUserInfoReq, func (c *userClient) DeleteUsers(ctx context.Context, in *DeleteUsersReq, opts ...grpc.CallOption) (*DeleteUsersResp, error) { out := new(DeleteUsersResp) - err := grpc.Invoke(ctx, "/user.user/DeleteUsers", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/DeleteUsers", in, out, opts...) if err != nil { return nil, err } @@ -1050,7 +3694,7 @@ func (c *userClient) DeleteUsers(ctx context.Context, in *DeleteUsersReq, opts . func (c *userClient) GetAllUserID(ctx context.Context, in *GetAllUserIDReq, opts ...grpc.CallOption) (*GetAllUserIDResp, error) { out := new(GetAllUserIDResp) - err := grpc.Invoke(ctx, "/user.user/GetAllUserID", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/GetAllUserID", in, out, opts...) if err != nil { return nil, err } @@ -1059,7 +3703,7 @@ func (c *userClient) GetAllUserID(ctx context.Context, in *GetAllUserIDReq, opts func (c *userClient) SetReceiveMessageOpt(ctx context.Context, in *SetReceiveMessageOptReq, opts ...grpc.CallOption) (*SetReceiveMessageOptResp, error) { out := new(SetReceiveMessageOptResp) - err := grpc.Invoke(ctx, "/user.user/SetReceiveMessageOpt", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/SetReceiveMessageOpt", in, out, opts...) if err != nil { return nil, err } @@ -1068,7 +3712,7 @@ func (c *userClient) SetReceiveMessageOpt(ctx context.Context, in *SetReceiveMes func (c *userClient) GetReceiveMessageOpt(ctx context.Context, in *GetReceiveMessageOptReq, opts ...grpc.CallOption) (*GetReceiveMessageOptResp, error) { out := new(GetReceiveMessageOptResp) - err := grpc.Invoke(ctx, "/user.user/GetReceiveMessageOpt", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/GetReceiveMessageOpt", in, out, opts...) if err != nil { return nil, err } @@ -1077,7 +3721,7 @@ func (c *userClient) GetReceiveMessageOpt(ctx context.Context, in *GetReceiveMes func (c *userClient) GetAllConversationMsgOpt(ctx context.Context, in *GetAllConversationMsgOptReq, opts ...grpc.CallOption) (*GetAllConversationMsgOptResp, error) { out := new(GetAllConversationMsgOptResp) - err := grpc.Invoke(ctx, "/user.user/GetAllConversationMsgOpt", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/GetAllConversationMsgOpt", in, out, opts...) if err != nil { return nil, err } @@ -1086,15 +3730,113 @@ func (c *userClient) GetAllConversationMsgOpt(ctx context.Context, in *GetAllCon func (c *userClient) AccountCheck(ctx context.Context, in *AccountCheckReq, opts ...grpc.CallOption) (*AccountCheckResp, error) { out := new(AccountCheckResp) - err := grpc.Invoke(ctx, "/user.user/AccountCheck", in, out, c.cc, opts...) + err := c.cc.Invoke(ctx, "/user.user/AccountCheck", in, out, opts...) if err != nil { return nil, err } return out, nil } -// Server API for User service +func (c *userClient) GetUserById(ctx context.Context, in *GetUserByIdReq, opts ...grpc.CallOption) (*GetUserByIdResp, error) { + out := new(GetUserByIdResp) + err := c.cc.Invoke(ctx, "/user.user/GetUserById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} +func (c *userClient) GetUsersByName(ctx context.Context, in *GetUsersByNameReq, opts ...grpc.CallOption) (*GetUsersByNameResp, error) { + out := new(GetUsersByNameResp) + err := c.cc.Invoke(ctx, "/user.user/GetUsersByName", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) ResignUser(ctx context.Context, in *ResignUserReq, opts ...grpc.CallOption) (*ResignUserResp, error) { + out := new(ResignUserResp) + err := c.cc.Invoke(ctx, "/user.user/ResignUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) AlterUser(ctx context.Context, in *AlterUserReq, opts ...grpc.CallOption) (*AlterUserResp, error) { + out := new(AlterUserResp) + err := c.cc.Invoke(ctx, "/user.user/AlterUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetUsers(ctx context.Context, in *GetUsersReq, opts ...grpc.CallOption) (*GetUsersResp, error) { + out := new(GetUsersResp) + err := c.cc.Invoke(ctx, "/user.user/GetUsers", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) AddUser(ctx context.Context, in *AddUserReq, opts ...grpc.CallOption) (*AddUserResp, error) { + out := new(AddUserResp) + err := c.cc.Invoke(ctx, "/user.user/AddUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) BlockUser(ctx context.Context, in *BlockUserReq, opts ...grpc.CallOption) (*BlockUserResp, error) { + out := new(BlockUserResp) + err := c.cc.Invoke(ctx, "/user.user/BlockUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) UnBlockUser(ctx context.Context, in *UnBlockUserReq, opts ...grpc.CallOption) (*UnBlockUserResp, error) { + out := new(UnBlockUserResp) + err := c.cc.Invoke(ctx, "/user.user/UnBlockUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetBlockUsers(ctx context.Context, in *GetBlockUsersReq, opts ...grpc.CallOption) (*GetBlockUsersResp, error) { + out := new(GetBlockUsersResp) + err := c.cc.Invoke(ctx, "/user.user/GetBlockUsers", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) GetBlockUserById(ctx context.Context, in *GetBlockUserByIdReq, opts ...grpc.CallOption) (*GetBlockUserByIdResp, error) { + out := new(GetBlockUserByIdResp) + err := c.cc.Invoke(ctx, "/user.user/GetBlockUserById", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *userClient) DeleteUser(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserResp, error) { + out := new(DeleteUserResp) + err := c.cc.Invoke(ctx, "/user.user/DeleteUser", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// UserServer is the server API for User service. type UserServer interface { GetUserInfo(context.Context, *GetUserInfoReq) (*GetUserInfoResp, error) UpdateUserInfo(context.Context, *UpdateUserInfoReq) (*UpdateUserInfoResp, error) @@ -1104,6 +3846,79 @@ type UserServer interface { GetReceiveMessageOpt(context.Context, *GetReceiveMessageOptReq) (*GetReceiveMessageOptResp, error) GetAllConversationMsgOpt(context.Context, *GetAllConversationMsgOptReq) (*GetAllConversationMsgOptResp, error) AccountCheck(context.Context, *AccountCheckReq) (*AccountCheckResp, error) + GetUserById(context.Context, *GetUserByIdReq) (*GetUserByIdResp, error) + GetUsersByName(context.Context, *GetUsersByNameReq) (*GetUsersByNameResp, error) + ResignUser(context.Context, *ResignUserReq) (*ResignUserResp, error) + AlterUser(context.Context, *AlterUserReq) (*AlterUserResp, error) + GetUsers(context.Context, *GetUsersReq) (*GetUsersResp, error) + AddUser(context.Context, *AddUserReq) (*AddUserResp, error) + BlockUser(context.Context, *BlockUserReq) (*BlockUserResp, error) + UnBlockUser(context.Context, *UnBlockUserReq) (*UnBlockUserResp, error) + GetBlockUsers(context.Context, *GetBlockUsersReq) (*GetBlockUsersResp, error) + GetBlockUserById(context.Context, *GetBlockUserByIdReq) (*GetBlockUserByIdResp, error) + DeleteUser(context.Context, *DeleteUserReq) (*DeleteUserResp, error) +} + +// UnimplementedUserServer can be embedded to have forward compatible implementations. +type UnimplementedUserServer struct { +} + +func (*UnimplementedUserServer) GetUserInfo(context.Context, *GetUserInfoReq) (*GetUserInfoResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetUserInfo not implemented") +} +func (*UnimplementedUserServer) UpdateUserInfo(context.Context, *UpdateUserInfoReq) (*UpdateUserInfoResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateUserInfo not implemented") +} +func (*UnimplementedUserServer) DeleteUsers(context.Context, *DeleteUsersReq) (*DeleteUsersResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteUsers not implemented") +} +func (*UnimplementedUserServer) GetAllUserID(context.Context, *GetAllUserIDReq) (*GetAllUserIDResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetAllUserID not implemented") +} +func (*UnimplementedUserServer) SetReceiveMessageOpt(context.Context, *SetReceiveMessageOptReq) (*SetReceiveMessageOptResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetReceiveMessageOpt not implemented") +} +func (*UnimplementedUserServer) GetReceiveMessageOpt(context.Context, *GetReceiveMessageOptReq) (*GetReceiveMessageOptResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetReceiveMessageOpt not implemented") +} +func (*UnimplementedUserServer) GetAllConversationMsgOpt(context.Context, *GetAllConversationMsgOptReq) (*GetAllConversationMsgOptResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetAllConversationMsgOpt not implemented") +} +func (*UnimplementedUserServer) AccountCheck(context.Context, *AccountCheckReq) (*AccountCheckResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method AccountCheck not implemented") +} +func (*UnimplementedUserServer) GetUserById(context.Context, *GetUserByIdReq) (*GetUserByIdResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetUserById not implemented") +} +func (*UnimplementedUserServer) GetUsersByName(context.Context, *GetUsersByNameReq) (*GetUsersByNameResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetUsersByName not implemented") +} +func (*UnimplementedUserServer) ResignUser(context.Context, *ResignUserReq) (*ResignUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method ResignUser not implemented") +} +func (*UnimplementedUserServer) AlterUser(context.Context, *AlterUserReq) (*AlterUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method AlterUser not implemented") +} +func (*UnimplementedUserServer) GetUsers(context.Context, *GetUsersReq) (*GetUsersResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetUsers not implemented") +} +func (*UnimplementedUserServer) AddUser(context.Context, *AddUserReq) (*AddUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddUser not implemented") +} +func (*UnimplementedUserServer) BlockUser(context.Context, *BlockUserReq) (*BlockUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method BlockUser not implemented") +} +func (*UnimplementedUserServer) UnBlockUser(context.Context, *UnBlockUserReq) (*UnBlockUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method UnBlockUser not implemented") +} +func (*UnimplementedUserServer) GetBlockUsers(context.Context, *GetBlockUsersReq) (*GetBlockUsersResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBlockUsers not implemented") +} +func (*UnimplementedUserServer) GetBlockUserById(context.Context, *GetBlockUserByIdReq) (*GetBlockUserByIdResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetBlockUserById not implemented") +} +func (*UnimplementedUserServer) DeleteUser(context.Context, *DeleteUserReq) (*DeleteUserResp, error) { + return nil, status.Errorf(codes.Unimplemented, "method DeleteUser not implemented") } func RegisterUserServer(s *grpc.Server, srv UserServer) { @@ -1254,6 +4069,204 @@ func _User_AccountCheck_Handler(srv interface{}, ctx context.Context, dec func(i return interceptor(ctx, in, info, handler) } +func _User_GetUserById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetUserByIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetUserById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/GetUserById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetUserById(ctx, req.(*GetUserByIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetUsersByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetUsersByNameReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetUsersByName(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/GetUsersByName", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetUsersByName(ctx, req.(*GetUsersByNameReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_ResignUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ResignUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).ResignUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/ResignUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).ResignUser(ctx, req.(*ResignUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_AlterUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AlterUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).AlterUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/AlterUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).AlterUser(ctx, req.(*AlterUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetUsersReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetUsers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/GetUsers", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetUsers(ctx, req.(*GetUsersReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_AddUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AddUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).AddUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/AddUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).AddUser(ctx, req.(*AddUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_BlockUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(BlockUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).BlockUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/BlockUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).BlockUser(ctx, req.(*BlockUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_UnBlockUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnBlockUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).UnBlockUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/UnBlockUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).UnBlockUser(ctx, req.(*UnBlockUserReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetBlockUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBlockUsersReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetBlockUsers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/GetBlockUsers", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetBlockUsers(ctx, req.(*GetBlockUsersReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_GetBlockUserById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBlockUserByIdReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).GetBlockUserById(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/GetBlockUserById", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).GetBlockUserById(ctx, req.(*GetBlockUserByIdReq)) + } + return interceptor(ctx, in, info, handler) +} + +func _User_DeleteUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteUserReq) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UserServer).DeleteUser(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/user.user/DeleteUser", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(UserServer).DeleteUser(ctx, req.(*DeleteUserReq)) + } + return interceptor(ctx, in, info, handler) +} + var _User_serviceDesc = grpc.ServiceDesc{ ServiceName: "user.user", HandlerType: (*UserServer)(nil), @@ -1290,65 +4303,51 @@ var _User_serviceDesc = grpc.ServiceDesc{ MethodName: "AccountCheck", Handler: _User_AccountCheck_Handler, }, + { + MethodName: "GetUserById", + Handler: _User_GetUserById_Handler, + }, + { + MethodName: "GetUsersByName", + Handler: _User_GetUsersByName_Handler, + }, + { + MethodName: "ResignUser", + Handler: _User_ResignUser_Handler, + }, + { + MethodName: "AlterUser", + Handler: _User_AlterUser_Handler, + }, + { + MethodName: "GetUsers", + Handler: _User_GetUsers_Handler, + }, + { + MethodName: "AddUser", + Handler: _User_AddUser_Handler, + }, + { + MethodName: "BlockUser", + Handler: _User_BlockUser_Handler, + }, + { + MethodName: "UnBlockUser", + Handler: _User_UnBlockUser_Handler, + }, + { + MethodName: "GetBlockUsers", + Handler: _User_GetBlockUsers_Handler, + }, + { + MethodName: "GetBlockUserById", + Handler: _User_GetBlockUserById_Handler, + }, + { + MethodName: "DeleteUser", + Handler: _User_DeleteUser_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "user/user.proto", } - -func init() { proto.RegisterFile("user/user.proto", fileDescriptor_user_9cd4aaf870b6d3b5) } - -var fileDescriptor_user_9cd4aaf870b6d3b5 = []byte{ - // 819 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0x13, 0x3b, - 0x14, 0xd6, 0x24, 0x69, 0x6f, 0x73, 0xd2, 0x26, 0xb9, 0x56, 0x6f, 0x3b, 0x77, 0x0a, 0x55, 0x6a, - 0x21, 0x88, 0xba, 0x48, 0x50, 0x59, 0x20, 0x81, 0x00, 0x95, 0x54, 0x8d, 0x2a, 0x88, 0x82, 0xa6, - 0xea, 0x86, 0x4d, 0x34, 0x24, 0x26, 0x44, 0x4d, 0xc6, 0xc6, 0x9e, 0xb4, 0x02, 0xb6, 0xac, 0x78, - 0x05, 0x16, 0x2c, 0x79, 0x06, 0x5e, 0x83, 0x17, 0xe0, 0x55, 0xd0, 0xd8, 0x33, 0x89, 0xe7, 0x27, - 0xd3, 0x12, 0x24, 0xc4, 0x66, 0x34, 0x3e, 0x3e, 0x3e, 0xfe, 0xbe, 0xef, 0x1c, 0xdb, 0x07, 0x2a, - 0x53, 0x41, 0x78, 0xd3, 0xff, 0x34, 0x18, 0xa7, 0x1e, 0x45, 0x05, 0xff, 0xdf, 0xda, 0xeb, 0x32, - 0xe2, 0xf6, 0x4e, 0x3a, 0x4d, 0x76, 0x3e, 0x6c, 0xca, 0x89, 0xa6, 0x18, 0x9c, 0xf7, 0x2e, 0x45, - 0xf3, 0x52, 0x28, 0x47, 0xfc, 0x18, 0xa0, 0x45, 0x27, 0x13, 0xea, 0xda, 0x44, 0x30, 0x64, 0xc2, - 0x3f, 0x84, 0xf3, 0x16, 0x1d, 0x10, 0xd3, 0xa8, 0x19, 0xf5, 0x15, 0x3b, 0x1c, 0xa2, 0x2d, 0x58, - 0x25, 0x9c, 0x77, 0xc4, 0xd0, 0xcc, 0xd5, 0x8c, 0x7a, 0xd1, 0x0e, 0x46, 0xf8, 0x3d, 0x94, 0x8f, - 0xc8, 0x98, 0x78, 0xe4, 0x4c, 0x10, 0x2e, 0x6c, 0xf2, 0x16, 0xed, 0x43, 0x75, 0x6e, 0x39, 0x39, - 0x7a, 0x3e, 0x12, 0x9e, 0x99, 0xab, 0xe5, 0xeb, 0x45, 0x3b, 0x61, 0x47, 0x16, 0xac, 0x75, 0x99, - 0x1a, 0x9b, 0x79, 0x19, 0x77, 0x36, 0x46, 0x35, 0x28, 0x75, 0x19, 0xe1, 0x8e, 0x37, 0xa2, 0xee, - 0xc9, 0x91, 0x59, 0x90, 0xd3, 0xba, 0x09, 0x53, 0xa8, 0x44, 0xf6, 0x16, 0x0c, 0xdd, 0xd5, 0xe9, - 0x48, 0x0e, 0xa5, 0x83, 0x6a, 0x43, 0x0a, 0x33, 0xb7, 0xdb, 0x3a, 0xe5, 0x7d, 0xa8, 0x1e, 0x3b, - 0xa3, 0x31, 0x19, 0x24, 0xe1, 0xc6, 0xed, 0xb8, 0x0b, 0x95, 0x36, 0xf1, 0x0e, 0xc7, 0x63, 0x65, - 0xf3, 0xd9, 0x5a, 0xb0, 0x46, 0x43, 0x06, 0x86, 0x62, 0x40, 0x35, 0x06, 0x54, 0x63, 0xa0, 0x84, - 0xd3, 0x4d, 0x78, 0x00, 0xd5, 0x68, 0xc0, 0xa5, 0x28, 0xec, 0x02, 0x24, 0xc0, 0x6b, 0x16, 0xfc, - 0x0e, 0x2a, 0x87, 0xfd, 0x3e, 0x9d, 0xba, 0x5e, 0xeb, 0x0d, 0xe9, 0x9f, 0xfb, 0xb0, 0xeb, 0x50, - 0x91, 0xff, 0xda, 0x3a, 0x43, 0xae, 0x8b, 0x9b, 0x23, 0x29, 0xca, 0x65, 0xa7, 0x28, 0x9f, 0x4c, - 0xd1, 0x0f, 0x03, 0xaa, 0xd1, 0xbd, 0x15, 0xc3, 0xfe, 0x35, 0x18, 0xce, 0x7d, 0x50, 0x1b, 0xc0, - 0x26, 0x62, 0x3a, 0xf6, 0x66, 0x0c, 0x4b, 0x07, 0x77, 0xd4, 0x8a, 0x78, 0xf4, 0xc6, 0xe9, 0xc8, - 0x1d, 0x8e, 0x65, 0x49, 0x9c, 0x7a, 0x8e, 0x37, 0x15, 0xb6, 0xb6, 0xd4, 0x7a, 0x01, 0xd5, 0xf8, - 0xbc, 0x5f, 0xda, 0x53, 0x3d, 0x81, 0xc1, 0x08, 0xdd, 0x82, 0x0d, 0x47, 0x05, 0x57, 0x8e, 0x01, - 0xfd, 0xa8, 0x11, 0xbb, 0x50, 0x6e, 0x13, 0x4f, 0x0a, 0xe2, 0xbe, 0xa6, 0xbe, 0xb6, 0xbb, 0x00, - 0xd3, 0xb8, 0xac, 0x9a, 0xe5, 0x37, 0x15, 0xfd, 0x68, 0xc8, 0x22, 0x9c, 0x6f, 0xb8, 0x94, 0xa0, - 0x4f, 0x60, 0x3d, 0x8c, 0x20, 0x51, 0xe6, 0xa5, 0xa4, 0x3b, 0x0d, 0x41, 0xf8, 0x05, 0xe1, 0x3d, - 0x87, 0x8d, 0x7a, 0xcc, 0xe1, 0xce, 0x44, 0x34, 0x66, 0x1b, 0x45, 0x16, 0xe0, 0x4f, 0x06, 0xfc, - 0x7b, 0xc6, 0x06, 0x4e, 0x70, 0x9c, 0x03, 0xea, 0xf7, 0x61, 0x2d, 0x1c, 0x06, 0x30, 0x32, 0x43, - 0xce, 0x9c, 0xaf, 0xd2, 0x84, 0x26, 0x35, 0xd1, 0x8f, 0xd1, 0x31, 0xa0, 0x38, 0x96, 0x65, 0x54, - 0xc1, 0xdf, 0x0c, 0xd8, 0x3e, 0x25, 0x9e, 0x4d, 0xfa, 0x64, 0x74, 0x41, 0x3a, 0x44, 0x08, 0x67, - 0x48, 0xba, 0xcc, 0x0b, 0xb2, 0x7a, 0xcc, 0xe9, 0x24, 0x72, 0xd4, 0x35, 0x0b, 0xaa, 0x42, 0x9e, - 0x32, 0x4f, 0x82, 0x5f, 0xb1, 0xfd, 0x5f, 0xd4, 0x00, 0xd4, 0xa7, 0xee, 0x05, 0xe1, 0x22, 0xc0, - 0x39, 0x53, 0xba, 0x68, 0xa7, 0xcc, 0xc4, 0x79, 0x16, 0x12, 0x3c, 0x23, 0x2a, 0xad, 0x44, 0x55, - 0xc2, 0xcf, 0xa0, 0x28, 0x91, 0xfa, 0xa5, 0x8e, 0x6e, 0x43, 0x39, 0xba, 0x41, 0x00, 0x38, 0x66, - 0xf5, 0x4b, 0x9f, 0xcb, 0x15, 0x01, 0xee, 0x60, 0x84, 0x3f, 0x1b, 0x60, 0xa6, 0x0b, 0xb1, 0x54, - 0xb5, 0x75, 0xe0, 0x7f, 0x7d, 0xe3, 0x19, 0x4e, 0xed, 0x34, 0x57, 0x54, 0x80, 0xd9, 0x94, 0xbd, - 0x78, 0x05, 0xfe, 0x6a, 0xc0, 0x76, 0x7b, 0xc9, 0x34, 0xa5, 0x27, 0x25, 0x77, 0xdd, 0xa4, 0xe4, - 0xb3, 0x93, 0x52, 0x88, 0x25, 0xc5, 0xd7, 0xb1, 0xfd, 0x87, 0x74, 0xcc, 0xff, 0xb2, 0x8e, 0x1f, - 0x60, 0x47, 0xbd, 0x3e, 0x2d, 0xcd, 0xa5, 0x23, 0x86, 0xd7, 0x94, 0xf2, 0xca, 0xe7, 0x2d, 0xeb, - 0x79, 0xc7, 0x5f, 0x0c, 0xb8, 0xb1, 0x78, 0xf7, 0xbf, 0x40, 0x9e, 0x83, 0xef, 0x05, 0x90, 0x6d, - 0x14, 0x7a, 0x00, 0x25, 0xed, 0xc6, 0x45, 0x9b, 0x2a, 0x46, 0xf4, 0xd6, 0xb7, 0xfe, 0x4b, 0xb1, - 0x0a, 0x86, 0x5a, 0x50, 0x8e, 0x5e, 0x4d, 0x68, 0x5b, 0x39, 0x26, 0x2e, 0x4f, 0xcb, 0x4c, 0x9f, - 0x10, 0xcc, 0x07, 0xa0, 0x35, 0x3a, 0x21, 0x80, 0x68, 0xdf, 0x15, 0x02, 0x88, 0x77, 0x44, 0x8f, - 0x60, 0x5d, 0x6f, 0x31, 0xd0, 0x1c, 0xa7, 0xde, 0xc7, 0x58, 0x5b, 0x69, 0x66, 0xc1, 0xd0, 0x19, - 0x6c, 0xa6, 0x5d, 0x04, 0xe8, 0xa6, 0xf2, 0x5f, 0x70, 0x5b, 0x5a, 0xbb, 0x59, 0xd3, 0x2a, 0x6c, - 0x3b, 0x23, 0x6c, 0x3b, 0x3b, 0xec, 0xc2, 0x23, 0xe5, 0xc8, 0xe3, 0x96, 0x5a, 0x53, 0x68, 0x4f, - 0x67, 0x98, 0x5a, 0xf1, 0x16, 0xbe, 0xca, 0x45, 0xe9, 0xa9, 0xb7, 0x1c, 0xa1, 0x9e, 0xb1, 0x06, - 0x2b, 0xd4, 0x33, 0xde, 0x9d, 0x3c, 0xdd, 0x78, 0x59, 0x6a, 0xc8, 0x46, 0xfd, 0xa1, 0xff, 0x79, - 0xb5, 0x2a, 0xbb, 0xf0, 0x7b, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x95, 0x5e, 0xfc, 0xe6, 0xc1, - 0x0b, 0x00, 0x00, -} diff --git a/pkg/proto/user/user.proto b/pkg/proto/user/user.proto index 75455f7a0..649cd2f74 100644 --- a/pkg/proto/user/user.proto +++ b/pkg/proto/user/user.proto @@ -13,6 +13,7 @@ message DeleteUsersReq{ string OpUserID = 3; string OperationID = 4; } + message DeleteUsersResp{ CommonResp CommonResp = 1; repeated string FailedUserIDList = 2; @@ -98,7 +99,7 @@ message GetReceiveMessageOptResp{ message GetAllConversationMsgOptReq{ string FromUserID = 1; - string operationID = 2; + string operationID = 2; string OpUserID = 3; } message GetAllConversationMsgOptResp{ @@ -106,6 +107,137 @@ message GetAllConversationMsgOptResp{ repeated OptResult conversationOptResultList = 3; } +message ResignUserReq{ + string UserId = 1; + string OperationID = 2; +} + +message ResignUserResp{ + CommonResp commonResp = 1; +} + +message GetUserByIdReq{ + string UserId = 1; + string OperationID = 2; +} + +message User{ + string ProfilePhoto = 1; + string Nickname = 2; + string UserId = 3; + string CreateTime = 4; + bool IsBlock = 5; +} + +message GetUserByIdResp{ + CommonResp CommonResp = 1; + User user = 2; +} + +message GetUsersByNameReq { + string UserName = 1; + server_api_params.RequestPagination Pagination =2; + string OperationID = 3; +} + +message GetUsersByNameResp { + repeated User users = 1; + server_api_params.ResponsePagination Pagination = 2; + int32 UserNums = 3; +} + +message AlterUserReq{ + string UserId = 1; + string OperationID = 2; + int64 PhoneNumber = 3; + string Nickname = 4; + string Email = 5; +} + +message AlterUserResp{ + CommonResp CommonResp = 1; +} + +message GetUsersReq { + string OperationID = 1; + server_api_params.RequestPagination Pagination = 2; + string UserName = 3; +} + +message GetUsersResp{ + CommonResp CommonResp = 1; + repeated User user = 2; + server_api_params.ResponsePagination Pagination = 3; + int32 UserNums = 4; +} + +message AddUserReq{ + string OperationID = 1; + string PhoneNumber = 2; + string UserId = 3; + string name = 4; +} + +message AddUserResp{ + CommonResp CommonResp = 1; +} + + +message BlockUserReq{ + string UserId = 1; + string EndDisableTime = 2; + string OperationID = 3; +} + +message BlockUserResp{ + CommonResp CommonResp = 1; +} + +message UnBlockUserReq{ + string UserId = 1; + string OperationID = 2; +} + +message UnBlockUserResp{ + CommonResp CommonResp = 1; +} + +message GetBlockUsersReq{ + server_api_params.RequestPagination Pagination =1; + string OperationID = 2; + int32 BlockUserNum = 3; +} + +message BlockUser { + User User = 1; + string BeginDisableTime = 2; + string EndDisableTime = 3; +} + +message GetBlockUsersResp{ + CommonResp CommonResp = 1; + repeated BlockUser BlockUsers = 2; + server_api_params.ResponsePagination Pagination = 3; + int32 UserNums = 4; +} + +message GetBlockUserByIdReq { + string User_id = 1; + string OperationID = 2; +} + +message GetBlockUserByIdResp { + BlockUser BlockUser = 2; +} + +message DeleteUserReq { + string User_id = 1; + string OperationID = 2; +} + +message DeleteUserResp { + +} service user { rpc GetUserInfo(GetUserInfoReq) returns(GetUserInfoResp); @@ -116,4 +248,16 @@ service user { rpc GetReceiveMessageOpt(GetReceiveMessageOptReq)returns(GetReceiveMessageOptResp); rpc GetAllConversationMsgOpt(GetAllConversationMsgOptReq)returns(GetAllConversationMsgOptResp); rpc AccountCheck(AccountCheckReq)returns(AccountCheckResp); + + rpc GetUserById(GetUserByIdReq) returns (GetUserByIdResp); + rpc GetUsersByName(GetUsersByNameReq) returns (GetUsersByNameResp); + rpc ResignUser(ResignUserReq) returns (ResignUserResp); + rpc AlterUser(AlterUserReq) returns (AlterUserResp); + rpc GetUsers(GetUsersReq) returns (GetUsersResp); + rpc AddUser(AddUserReq) returns (AddUserResp); + rpc BlockUser(BlockUserReq) returns (BlockUserResp); + rpc UnBlockUser(UnBlockUserReq) returns (UnBlockUserResp); + rpc GetBlockUsers(GetBlockUsersReq) returns (GetBlockUsersResp); + rpc GetBlockUserById(GetBlockUserByIdReq) returns (GetBlockUserByIdResp); + rpc DeleteUser(DeleteUserReq) returns (DeleteUserResp); } diff --git a/pkg/utils/time_format.go b/pkg/utils/time_format.go index b24d11398..c8f6e21fa 100644 --- a/pkg/utils/time_format.go +++ b/pkg/utils/time_format.go @@ -78,3 +78,8 @@ func TimeStringFormatTimeUnix(timeFormat string, timeSrc string) int64 { tm, _ := time.Parse(timeFormat, timeSrc) return tm.Unix() } + +func TimeStringToTime(timeString string) (time.Time, error) { + t, err := time.Parse("2006-01-02", timeString) + return t, err +}