1036 lines
39 KiB
Go
1036 lines
39 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.6.2
|
|
// - protoc v3.19.4
|
|
// source: chore/chore.proto
|
|
|
|
package chore
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
)
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
// Requires gRPC-Go v1.64.0 or later.
|
|
const _ = grpc.SupportPackageIsVersion9
|
|
|
|
const (
|
|
Chore_Policy_FullMethodName = "/chore.Chore/Policy"
|
|
Chore_Upload_FullMethodName = "/chore.Chore/Upload"
|
|
Chore_OssSignature_FullMethodName = "/chore.Chore/OssSignature"
|
|
Chore_Test_FullMethodName = "/chore.Chore/Test"
|
|
Chore_DecryptMobile_FullMethodName = "/chore.Chore/DecryptMobile"
|
|
Chore_Regions_FullMethodName = "/chore.Chore/Regions"
|
|
Chore_SendSms_FullMethodName = "/chore.Chore/SendSms"
|
|
Chore_ApiSystemItems_FullMethodName = "/chore.Chore/ApiSystemItems"
|
|
Chore_ApiSystemInfo_FullMethodName = "/chore.Chore/ApiSystemInfo"
|
|
Chore_ApiAnswerItems_FullMethodName = "/chore.Chore/ApiAnswerItems"
|
|
Chore_ApiAnswerIProgress_FullMethodName = "/chore.Chore/ApiAnswerIProgress"
|
|
Chore_ApiAnswerSave_FullMethodName = "/chore.Chore/ApiAnswerSave"
|
|
Chore_AnswerItems_FullMethodName = "/chore.Chore/AnswerItems"
|
|
Chore_AnswerStatus_FullMethodName = "/chore.Chore/AnswerStatus"
|
|
Chore_AnswerInfo_FullMethodName = "/chore.Chore/AnswerInfo"
|
|
Chore_AnswerCreate_FullMethodName = "/chore.Chore/AnswerCreate"
|
|
Chore_AnswerEdit_FullMethodName = "/chore.Chore/AnswerEdit"
|
|
Chore_SystemEdit_FullMethodName = "/chore.Chore/SystemEdit"
|
|
Chore_SystemStatus_FullMethodName = "/chore.Chore/SystemStatus"
|
|
Chore_SystemInfo_FullMethodName = "/chore.Chore/SystemInfo"
|
|
Chore_SystemItems_FullMethodName = "/chore.Chore/SystemItems"
|
|
Chore_InternalUpload_FullMethodName = "/chore.Chore/InternalUpload"
|
|
Chore_RegionsByIds_FullMethodName = "/chore.Chore/RegionsByIds"
|
|
Chore_InternalActionApplyLogCreate_FullMethodName = "/chore.Chore/InternalActionApplyLogCreate"
|
|
Chore_SendPassword_FullMethodName = "/chore.Chore/SendPassword"
|
|
)
|
|
|
|
// ChoreClient is the client API for Chore service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
|
type ChoreClient interface {
|
|
Policy(ctx context.Context, in *PolicyReq, opts ...grpc.CallOption) (*Response, error)
|
|
Upload(ctx context.Context, in *UploadReq, opts ...grpc.CallOption) (*Response, error)
|
|
OssSignature(ctx context.Context, in *OssSignatureReq, opts ...grpc.CallOption) (*Response, error)
|
|
Test(ctx context.Context, in *TestReq, opts ...grpc.CallOption) (*Response, error)
|
|
DecryptMobile(ctx context.Context, in *DecryptMobileReq, opts ...grpc.CallOption) (*Response, error)
|
|
Regions(ctx context.Context, in *RegionsReq, opts ...grpc.CallOption) (*Response, error)
|
|
SendSms(ctx context.Context, in *SendSmsReq, opts ...grpc.CallOption) (*Response, error)
|
|
ApiSystemItems(ctx context.Context, in *ApiSystemReq, opts ...grpc.CallOption) (*Response, error)
|
|
ApiSystemInfo(ctx context.Context, in *ApiSystemReq, opts ...grpc.CallOption) (*Response, error)
|
|
ApiAnswerItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
|
|
ApiAnswerIProgress(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
|
|
ApiAnswerSave(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
|
|
// ******************** 管理员接口 ********************
|
|
AnswerItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
|
|
AnswerStatus(ctx context.Context, in *StatusReq, opts ...grpc.CallOption) (*Response, error)
|
|
AnswerInfo(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error)
|
|
AnswerCreate(ctx context.Context, in *EditReq, opts ...grpc.CallOption) (*Response, error)
|
|
AnswerEdit(ctx context.Context, in *EditReq, opts ...grpc.CallOption) (*Response, error)
|
|
SystemEdit(ctx context.Context, in *SystemEditReq, opts ...grpc.CallOption) (*Response, error)
|
|
SystemStatus(ctx context.Context, in *StatusReq, opts ...grpc.CallOption) (*Response, error)
|
|
SystemInfo(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error)
|
|
SystemItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
|
|
InternalUpload(ctx context.Context, in *InternalUploadReq, opts ...grpc.CallOption) (*InternalUploadData, error)
|
|
RegionsByIds(ctx context.Context, in *RegionsByIdsReq, opts ...grpc.CallOption) (*RegionsByIdsData, error)
|
|
InternalActionApplyLogCreate(ctx context.Context, in *InternalActionApplyLogCreateReq, opts ...grpc.CallOption) (*InternalActionApplyLogCreateData, error)
|
|
SendPassword(ctx context.Context, in *SendPasswordReq, opts ...grpc.CallOption) (*SendPasswordResp, error)
|
|
}
|
|
|
|
type choreClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewChoreClient(cc grpc.ClientConnInterface) ChoreClient {
|
|
return &choreClient{cc}
|
|
}
|
|
|
|
func (c *choreClient) Policy(ctx context.Context, in *PolicyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_Policy_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) Upload(ctx context.Context, in *UploadReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_Upload_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) OssSignature(ctx context.Context, in *OssSignatureReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_OssSignature_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) Test(ctx context.Context, in *TestReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_Test_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) DecryptMobile(ctx context.Context, in *DecryptMobileReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_DecryptMobile_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) Regions(ctx context.Context, in *RegionsReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_Regions_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SendSms(ctx context.Context, in *SendSmsReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_SendSms_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) ApiSystemItems(ctx context.Context, in *ApiSystemReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_ApiSystemItems_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) ApiSystemInfo(ctx context.Context, in *ApiSystemReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_ApiSystemInfo_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) ApiAnswerItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_ApiAnswerItems_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) ApiAnswerIProgress(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_ApiAnswerIProgress_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) ApiAnswerSave(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_ApiAnswerSave_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) AnswerItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_AnswerItems_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) AnswerStatus(ctx context.Context, in *StatusReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_AnswerStatus_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) AnswerInfo(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_AnswerInfo_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) AnswerCreate(ctx context.Context, in *EditReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_AnswerCreate_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) AnswerEdit(ctx context.Context, in *EditReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_AnswerEdit_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SystemEdit(ctx context.Context, in *SystemEditReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_SystemEdit_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SystemStatus(ctx context.Context, in *StatusReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_SystemStatus_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SystemInfo(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_SystemInfo_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SystemItems(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(Response)
|
|
err := c.cc.Invoke(ctx, Chore_SystemItems_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) InternalUpload(ctx context.Context, in *InternalUploadReq, opts ...grpc.CallOption) (*InternalUploadData, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(InternalUploadData)
|
|
err := c.cc.Invoke(ctx, Chore_InternalUpload_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) RegionsByIds(ctx context.Context, in *RegionsByIdsReq, opts ...grpc.CallOption) (*RegionsByIdsData, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RegionsByIdsData)
|
|
err := c.cc.Invoke(ctx, Chore_RegionsByIds_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) InternalActionApplyLogCreate(ctx context.Context, in *InternalActionApplyLogCreateReq, opts ...grpc.CallOption) (*InternalActionApplyLogCreateData, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(InternalActionApplyLogCreateData)
|
|
err := c.cc.Invoke(ctx, Chore_InternalActionApplyLogCreate_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *choreClient) SendPassword(ctx context.Context, in *SendPasswordReq, opts ...grpc.CallOption) (*SendPasswordResp, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SendPasswordResp)
|
|
err := c.cc.Invoke(ctx, Chore_SendPassword_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ChoreServer is the server API for Chore service.
|
|
// All implementations must embed UnimplementedChoreServer
|
|
// for forward compatibility.
|
|
type ChoreServer interface {
|
|
Policy(context.Context, *PolicyReq) (*Response, error)
|
|
Upload(context.Context, *UploadReq) (*Response, error)
|
|
OssSignature(context.Context, *OssSignatureReq) (*Response, error)
|
|
Test(context.Context, *TestReq) (*Response, error)
|
|
DecryptMobile(context.Context, *DecryptMobileReq) (*Response, error)
|
|
Regions(context.Context, *RegionsReq) (*Response, error)
|
|
SendSms(context.Context, *SendSmsReq) (*Response, error)
|
|
ApiSystemItems(context.Context, *ApiSystemReq) (*Response, error)
|
|
ApiSystemInfo(context.Context, *ApiSystemReq) (*Response, error)
|
|
ApiAnswerItems(context.Context, *EmptyReq) (*Response, error)
|
|
ApiAnswerIProgress(context.Context, *EmptyReq) (*Response, error)
|
|
ApiAnswerSave(context.Context, *EmptyReq) (*Response, error)
|
|
// ******************** 管理员接口 ********************
|
|
AnswerItems(context.Context, *EmptyReq) (*Response, error)
|
|
AnswerStatus(context.Context, *StatusReq) (*Response, error)
|
|
AnswerInfo(context.Context, *IdReq) (*Response, error)
|
|
AnswerCreate(context.Context, *EditReq) (*Response, error)
|
|
AnswerEdit(context.Context, *EditReq) (*Response, error)
|
|
SystemEdit(context.Context, *SystemEditReq) (*Response, error)
|
|
SystemStatus(context.Context, *StatusReq) (*Response, error)
|
|
SystemInfo(context.Context, *IdReq) (*Response, error)
|
|
SystemItems(context.Context, *EmptyReq) (*Response, error)
|
|
InternalUpload(context.Context, *InternalUploadReq) (*InternalUploadData, error)
|
|
RegionsByIds(context.Context, *RegionsByIdsReq) (*RegionsByIdsData, error)
|
|
InternalActionApplyLogCreate(context.Context, *InternalActionApplyLogCreateReq) (*InternalActionApplyLogCreateData, error)
|
|
SendPassword(context.Context, *SendPasswordReq) (*SendPasswordResp, error)
|
|
mustEmbedUnimplementedChoreServer()
|
|
}
|
|
|
|
// UnimplementedChoreServer must be embedded to have
|
|
// forward compatible implementations.
|
|
//
|
|
// NOTE: this should be embedded by value instead of pointer to avoid a nil
|
|
// pointer dereference when methods are called.
|
|
type UnimplementedChoreServer struct{}
|
|
|
|
func (UnimplementedChoreServer) Policy(context.Context, *PolicyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Policy not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) Upload(context.Context, *UploadReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Upload not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) OssSignature(context.Context, *OssSignatureReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method OssSignature not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) Test(context.Context, *TestReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Test not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) DecryptMobile(context.Context, *DecryptMobileReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DecryptMobile not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) Regions(context.Context, *RegionsReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Regions not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SendSms(context.Context, *SendSmsReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SendSms not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) ApiSystemItems(context.Context, *ApiSystemReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApiSystemItems not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) ApiSystemInfo(context.Context, *ApiSystemReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApiSystemInfo not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) ApiAnswerItems(context.Context, *EmptyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApiAnswerItems not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) ApiAnswerIProgress(context.Context, *EmptyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApiAnswerIProgress not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) ApiAnswerSave(context.Context, *EmptyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApiAnswerSave not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) AnswerItems(context.Context, *EmptyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AnswerItems not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) AnswerStatus(context.Context, *StatusReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AnswerStatus not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) AnswerInfo(context.Context, *IdReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AnswerInfo not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) AnswerCreate(context.Context, *EditReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AnswerCreate not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) AnswerEdit(context.Context, *EditReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method AnswerEdit not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SystemEdit(context.Context, *SystemEditReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SystemEdit not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SystemStatus(context.Context, *StatusReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SystemStatus not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SystemInfo(context.Context, *IdReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SystemInfo not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SystemItems(context.Context, *EmptyReq) (*Response, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SystemItems not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) InternalUpload(context.Context, *InternalUploadReq) (*InternalUploadData, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method InternalUpload not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) RegionsByIds(context.Context, *RegionsByIdsReq) (*RegionsByIdsData, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RegionsByIds not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) InternalActionApplyLogCreate(context.Context, *InternalActionApplyLogCreateReq) (*InternalActionApplyLogCreateData, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method InternalActionApplyLogCreate not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) SendPassword(context.Context, *SendPasswordReq) (*SendPasswordResp, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SendPassword not implemented")
|
|
}
|
|
func (UnimplementedChoreServer) mustEmbedUnimplementedChoreServer() {}
|
|
func (UnimplementedChoreServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeChoreServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to ChoreServer will
|
|
// result in compilation errors.
|
|
type UnsafeChoreServer interface {
|
|
mustEmbedUnimplementedChoreServer()
|
|
}
|
|
|
|
func RegisterChoreServer(s grpc.ServiceRegistrar, srv ChoreServer) {
|
|
// If the following call panics, it indicates UnimplementedChoreServer was
|
|
// embedded by pointer and is nil. This will cause panics if an
|
|
// unimplemented method is ever invoked, so we test this at initialization
|
|
// time to prevent it from happening at runtime later due to I/O.
|
|
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
|
|
t.testEmbeddedByValue()
|
|
}
|
|
s.RegisterService(&Chore_ServiceDesc, srv)
|
|
}
|
|
|
|
func _Chore_Policy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(PolicyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).Policy(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_Policy_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).Policy(ctx, req.(*PolicyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_Upload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UploadReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).Upload(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_Upload_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).Upload(ctx, req.(*UploadReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_OssSignature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(OssSignatureReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).OssSignature(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_OssSignature_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).OssSignature(ctx, req.(*OssSignatureReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_Test_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TestReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).Test(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_Test_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).Test(ctx, req.(*TestReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_DecryptMobile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DecryptMobileReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).DecryptMobile(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_DecryptMobile_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).DecryptMobile(ctx, req.(*DecryptMobileReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_Regions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RegionsReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).Regions(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_Regions_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).Regions(ctx, req.(*RegionsReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SendSms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SendSmsReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SendSms(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SendSms_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SendSms(ctx, req.(*SendSmsReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_ApiSystemItems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ApiSystemReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).ApiSystemItems(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_ApiSystemItems_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).ApiSystemItems(ctx, req.(*ApiSystemReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_ApiSystemInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ApiSystemReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).ApiSystemInfo(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_ApiSystemInfo_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).ApiSystemInfo(ctx, req.(*ApiSystemReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_ApiAnswerItems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EmptyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).ApiAnswerItems(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_ApiAnswerItems_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).ApiAnswerItems(ctx, req.(*EmptyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_ApiAnswerIProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EmptyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).ApiAnswerIProgress(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_ApiAnswerIProgress_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).ApiAnswerIProgress(ctx, req.(*EmptyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_ApiAnswerSave_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EmptyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).ApiAnswerSave(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_ApiAnswerSave_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).ApiAnswerSave(ctx, req.(*EmptyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_AnswerItems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EmptyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).AnswerItems(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_AnswerItems_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).AnswerItems(ctx, req.(*EmptyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_AnswerStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StatusReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).AnswerStatus(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_AnswerStatus_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).AnswerStatus(ctx, req.(*StatusReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_AnswerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(IdReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).AnswerInfo(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_AnswerInfo_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).AnswerInfo(ctx, req.(*IdReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_AnswerCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EditReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).AnswerCreate(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_AnswerCreate_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).AnswerCreate(ctx, req.(*EditReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_AnswerEdit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EditReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).AnswerEdit(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_AnswerEdit_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).AnswerEdit(ctx, req.(*EditReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SystemEdit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SystemEditReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SystemEdit(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SystemEdit_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SystemEdit(ctx, req.(*SystemEditReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SystemStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StatusReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SystemStatus(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SystemStatus_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SystemStatus(ctx, req.(*StatusReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SystemInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(IdReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SystemInfo(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SystemInfo_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SystemInfo(ctx, req.(*IdReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SystemItems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(EmptyReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SystemItems(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SystemItems_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SystemItems(ctx, req.(*EmptyReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_InternalUpload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(InternalUploadReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).InternalUpload(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_InternalUpload_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).InternalUpload(ctx, req.(*InternalUploadReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_RegionsByIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RegionsByIdsReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).RegionsByIds(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_RegionsByIds_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).RegionsByIds(ctx, req.(*RegionsByIdsReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_InternalActionApplyLogCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(InternalActionApplyLogCreateReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).InternalActionApplyLogCreate(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_InternalActionApplyLogCreate_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).InternalActionApplyLogCreate(ctx, req.(*InternalActionApplyLogCreateReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _Chore_SendPassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SendPasswordReq)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChoreServer).SendPassword(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: Chore_SendPassword_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChoreServer).SendPassword(ctx, req.(*SendPasswordReq))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// Chore_ServiceDesc is the grpc.ServiceDesc for Chore service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var Chore_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "chore.Chore",
|
|
HandlerType: (*ChoreServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "Policy",
|
|
Handler: _Chore_Policy_Handler,
|
|
},
|
|
{
|
|
MethodName: "Upload",
|
|
Handler: _Chore_Upload_Handler,
|
|
},
|
|
{
|
|
MethodName: "OssSignature",
|
|
Handler: _Chore_OssSignature_Handler,
|
|
},
|
|
{
|
|
MethodName: "Test",
|
|
Handler: _Chore_Test_Handler,
|
|
},
|
|
{
|
|
MethodName: "DecryptMobile",
|
|
Handler: _Chore_DecryptMobile_Handler,
|
|
},
|
|
{
|
|
MethodName: "Regions",
|
|
Handler: _Chore_Regions_Handler,
|
|
},
|
|
{
|
|
MethodName: "SendSms",
|
|
Handler: _Chore_SendSms_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApiSystemItems",
|
|
Handler: _Chore_ApiSystemItems_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApiSystemInfo",
|
|
Handler: _Chore_ApiSystemInfo_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApiAnswerItems",
|
|
Handler: _Chore_ApiAnswerItems_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApiAnswerIProgress",
|
|
Handler: _Chore_ApiAnswerIProgress_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApiAnswerSave",
|
|
Handler: _Chore_ApiAnswerSave_Handler,
|
|
},
|
|
{
|
|
MethodName: "AnswerItems",
|
|
Handler: _Chore_AnswerItems_Handler,
|
|
},
|
|
{
|
|
MethodName: "AnswerStatus",
|
|
Handler: _Chore_AnswerStatus_Handler,
|
|
},
|
|
{
|
|
MethodName: "AnswerInfo",
|
|
Handler: _Chore_AnswerInfo_Handler,
|
|
},
|
|
{
|
|
MethodName: "AnswerCreate",
|
|
Handler: _Chore_AnswerCreate_Handler,
|
|
},
|
|
{
|
|
MethodName: "AnswerEdit",
|
|
Handler: _Chore_AnswerEdit_Handler,
|
|
},
|
|
{
|
|
MethodName: "SystemEdit",
|
|
Handler: _Chore_SystemEdit_Handler,
|
|
},
|
|
{
|
|
MethodName: "SystemStatus",
|
|
Handler: _Chore_SystemStatus_Handler,
|
|
},
|
|
{
|
|
MethodName: "SystemInfo",
|
|
Handler: _Chore_SystemInfo_Handler,
|
|
},
|
|
{
|
|
MethodName: "SystemItems",
|
|
Handler: _Chore_SystemItems_Handler,
|
|
},
|
|
{
|
|
MethodName: "InternalUpload",
|
|
Handler: _Chore_InternalUpload_Handler,
|
|
},
|
|
{
|
|
MethodName: "RegionsByIds",
|
|
Handler: _Chore_RegionsByIds_Handler,
|
|
},
|
|
{
|
|
MethodName: "InternalActionApplyLogCreate",
|
|
Handler: _Chore_InternalActionApplyLogCreate_Handler,
|
|
},
|
|
{
|
|
MethodName: "SendPassword",
|
|
Handler: _Chore_SendPassword_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "chore/chore.proto",
|
|
}
|