736 lines
30 KiB
Go
736 lines
30 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.6.2
|
|
// - protoc v7.35.0
|
|
// source: proto/game/v1/game.proto
|
|
|
|
package gamev1
|
|
|
|
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 (
|
|
GameAppService_ListGames_FullMethodName = "/hyapp.game.v1.GameAppService/ListGames"
|
|
GameAppService_ListRecentGames_FullMethodName = "/hyapp.game.v1.GameAppService/ListRecentGames"
|
|
GameAppService_GetBridgeScript_FullMethodName = "/hyapp.game.v1.GameAppService/GetBridgeScript"
|
|
GameAppService_LaunchGame_FullMethodName = "/hyapp.game.v1.GameAppService/LaunchGame"
|
|
)
|
|
|
|
// GameAppServiceClient is the client API for GameAppService 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 GameAppServiceClient interface {
|
|
ListGames(ctx context.Context, in *ListGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error)
|
|
ListRecentGames(ctx context.Context, in *ListRecentGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error)
|
|
GetBridgeScript(ctx context.Context, in *GetBridgeScriptRequest, opts ...grpc.CallOption) (*GetBridgeScriptResponse, error)
|
|
LaunchGame(ctx context.Context, in *LaunchGameRequest, opts ...grpc.CallOption) (*LaunchGameResponse, error)
|
|
}
|
|
|
|
type gameAppServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewGameAppServiceClient(cc grpc.ClientConnInterface) GameAppServiceClient {
|
|
return &gameAppServiceClient{cc}
|
|
}
|
|
|
|
func (c *gameAppServiceClient) ListGames(ctx context.Context, in *ListGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListGamesResponse)
|
|
err := c.cc.Invoke(ctx, GameAppService_ListGames_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAppServiceClient) ListRecentGames(ctx context.Context, in *ListRecentGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListGamesResponse)
|
|
err := c.cc.Invoke(ctx, GameAppService_ListRecentGames_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAppServiceClient) GetBridgeScript(ctx context.Context, in *GetBridgeScriptRequest, opts ...grpc.CallOption) (*GetBridgeScriptResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GetBridgeScriptResponse)
|
|
err := c.cc.Invoke(ctx, GameAppService_GetBridgeScript_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAppServiceClient) LaunchGame(ctx context.Context, in *LaunchGameRequest, opts ...grpc.CallOption) (*LaunchGameResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(LaunchGameResponse)
|
|
err := c.cc.Invoke(ctx, GameAppService_LaunchGame_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GameAppServiceServer is the server API for GameAppService service.
|
|
// All implementations must embed UnimplementedGameAppServiceServer
|
|
// for forward compatibility.
|
|
type GameAppServiceServer interface {
|
|
ListGames(context.Context, *ListGamesRequest) (*ListGamesResponse, error)
|
|
ListRecentGames(context.Context, *ListRecentGamesRequest) (*ListGamesResponse, error)
|
|
GetBridgeScript(context.Context, *GetBridgeScriptRequest) (*GetBridgeScriptResponse, error)
|
|
LaunchGame(context.Context, *LaunchGameRequest) (*LaunchGameResponse, error)
|
|
mustEmbedUnimplementedGameAppServiceServer()
|
|
}
|
|
|
|
// UnimplementedGameAppServiceServer 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 UnimplementedGameAppServiceServer struct{}
|
|
|
|
func (UnimplementedGameAppServiceServer) ListGames(context.Context, *ListGamesRequest) (*ListGamesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListGames not implemented")
|
|
}
|
|
func (UnimplementedGameAppServiceServer) ListRecentGames(context.Context, *ListRecentGamesRequest) (*ListGamesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListRecentGames not implemented")
|
|
}
|
|
func (UnimplementedGameAppServiceServer) GetBridgeScript(context.Context, *GetBridgeScriptRequest) (*GetBridgeScriptResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GetBridgeScript not implemented")
|
|
}
|
|
func (UnimplementedGameAppServiceServer) LaunchGame(context.Context, *LaunchGameRequest) (*LaunchGameResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method LaunchGame not implemented")
|
|
}
|
|
func (UnimplementedGameAppServiceServer) mustEmbedUnimplementedGameAppServiceServer() {}
|
|
func (UnimplementedGameAppServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeGameAppServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to GameAppServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeGameAppServiceServer interface {
|
|
mustEmbedUnimplementedGameAppServiceServer()
|
|
}
|
|
|
|
func RegisterGameAppServiceServer(s grpc.ServiceRegistrar, srv GameAppServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedGameAppServiceServer 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(&GameAppService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _GameAppService_ListGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListGamesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAppServiceServer).ListGames(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAppService_ListGames_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAppServiceServer).ListGames(ctx, req.(*ListGamesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAppService_ListRecentGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListRecentGamesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAppServiceServer).ListRecentGames(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAppService_ListRecentGames_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAppServiceServer).ListRecentGames(ctx, req.(*ListRecentGamesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAppService_GetBridgeScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetBridgeScriptRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAppServiceServer).GetBridgeScript(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAppService_GetBridgeScript_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAppServiceServer).GetBridgeScript(ctx, req.(*GetBridgeScriptRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAppService_LaunchGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(LaunchGameRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAppServiceServer).LaunchGame(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAppService_LaunchGame_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAppServiceServer).LaunchGame(ctx, req.(*LaunchGameRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// GameAppService_ServiceDesc is the grpc.ServiceDesc for GameAppService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var GameAppService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "hyapp.game.v1.GameAppService",
|
|
HandlerType: (*GameAppServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "ListGames",
|
|
Handler: _GameAppService_ListGames_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListRecentGames",
|
|
Handler: _GameAppService_ListRecentGames_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetBridgeScript",
|
|
Handler: _GameAppService_GetBridgeScript_Handler,
|
|
},
|
|
{
|
|
MethodName: "LaunchGame",
|
|
Handler: _GameAppService_LaunchGame_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "proto/game/v1/game.proto",
|
|
}
|
|
|
|
const (
|
|
GameCallbackService_HandleCallback_FullMethodName = "/hyapp.game.v1.GameCallbackService/HandleCallback"
|
|
)
|
|
|
|
// GameCallbackServiceClient is the client API for GameCallbackService 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 GameCallbackServiceClient interface {
|
|
HandleCallback(ctx context.Context, in *CallbackRequest, opts ...grpc.CallOption) (*CallbackResponse, error)
|
|
}
|
|
|
|
type gameCallbackServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewGameCallbackServiceClient(cc grpc.ClientConnInterface) GameCallbackServiceClient {
|
|
return &gameCallbackServiceClient{cc}
|
|
}
|
|
|
|
func (c *gameCallbackServiceClient) HandleCallback(ctx context.Context, in *CallbackRequest, opts ...grpc.CallOption) (*CallbackResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CallbackResponse)
|
|
err := c.cc.Invoke(ctx, GameCallbackService_HandleCallback_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GameCallbackServiceServer is the server API for GameCallbackService service.
|
|
// All implementations must embed UnimplementedGameCallbackServiceServer
|
|
// for forward compatibility.
|
|
type GameCallbackServiceServer interface {
|
|
HandleCallback(context.Context, *CallbackRequest) (*CallbackResponse, error)
|
|
mustEmbedUnimplementedGameCallbackServiceServer()
|
|
}
|
|
|
|
// UnimplementedGameCallbackServiceServer 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 UnimplementedGameCallbackServiceServer struct{}
|
|
|
|
func (UnimplementedGameCallbackServiceServer) HandleCallback(context.Context, *CallbackRequest) (*CallbackResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HandleCallback not implemented")
|
|
}
|
|
func (UnimplementedGameCallbackServiceServer) mustEmbedUnimplementedGameCallbackServiceServer() {}
|
|
func (UnimplementedGameCallbackServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeGameCallbackServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to GameCallbackServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeGameCallbackServiceServer interface {
|
|
mustEmbedUnimplementedGameCallbackServiceServer()
|
|
}
|
|
|
|
func RegisterGameCallbackServiceServer(s grpc.ServiceRegistrar, srv GameCallbackServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedGameCallbackServiceServer 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(&GameCallbackService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _GameCallbackService_HandleCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CallbackRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameCallbackServiceServer).HandleCallback(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameCallbackService_HandleCallback_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameCallbackServiceServer).HandleCallback(ctx, req.(*CallbackRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// GameCallbackService_ServiceDesc is the grpc.ServiceDesc for GameCallbackService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var GameCallbackService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "hyapp.game.v1.GameCallbackService",
|
|
HandlerType: (*GameCallbackServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "HandleCallback",
|
|
Handler: _GameCallbackService_HandleCallback_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "proto/game/v1/game.proto",
|
|
}
|
|
|
|
const (
|
|
GameCronService_ProcessLevelEventOutboxBatch_FullMethodName = "/hyapp.game.v1.GameCronService/ProcessLevelEventOutboxBatch"
|
|
)
|
|
|
|
// GameCronServiceClient is the client API for GameCronService 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.
|
|
//
|
|
// GameCronService 只给 cron-service 触发 game-service 拥有的补偿批处理。
|
|
type GameCronServiceClient interface {
|
|
ProcessLevelEventOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
|
|
}
|
|
|
|
type gameCronServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewGameCronServiceClient(cc grpc.ClientConnInterface) GameCronServiceClient {
|
|
return &gameCronServiceClient{cc}
|
|
}
|
|
|
|
func (c *gameCronServiceClient) ProcessLevelEventOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CronBatchResponse)
|
|
err := c.cc.Invoke(ctx, GameCronService_ProcessLevelEventOutboxBatch_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GameCronServiceServer is the server API for GameCronService service.
|
|
// All implementations must embed UnimplementedGameCronServiceServer
|
|
// for forward compatibility.
|
|
//
|
|
// GameCronService 只给 cron-service 触发 game-service 拥有的补偿批处理。
|
|
type GameCronServiceServer interface {
|
|
ProcessLevelEventOutboxBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
|
|
mustEmbedUnimplementedGameCronServiceServer()
|
|
}
|
|
|
|
// UnimplementedGameCronServiceServer 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 UnimplementedGameCronServiceServer struct{}
|
|
|
|
func (UnimplementedGameCronServiceServer) ProcessLevelEventOutboxBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ProcessLevelEventOutboxBatch not implemented")
|
|
}
|
|
func (UnimplementedGameCronServiceServer) mustEmbedUnimplementedGameCronServiceServer() {}
|
|
func (UnimplementedGameCronServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeGameCronServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to GameCronServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeGameCronServiceServer interface {
|
|
mustEmbedUnimplementedGameCronServiceServer()
|
|
}
|
|
|
|
func RegisterGameCronServiceServer(s grpc.ServiceRegistrar, srv GameCronServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedGameCronServiceServer 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(&GameCronService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _GameCronService_ProcessLevelEventOutboxBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CronBatchRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameCronServiceServer).ProcessLevelEventOutboxBatch(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameCronService_ProcessLevelEventOutboxBatch_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameCronServiceServer).ProcessLevelEventOutboxBatch(ctx, req.(*CronBatchRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// GameCronService_ServiceDesc is the grpc.ServiceDesc for GameCronService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var GameCronService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "hyapp.game.v1.GameCronService",
|
|
HandlerType: (*GameCronServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "ProcessLevelEventOutboxBatch",
|
|
Handler: _GameCronService_ProcessLevelEventOutboxBatch_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "proto/game/v1/game.proto",
|
|
}
|
|
|
|
const (
|
|
GameAdminService_ListPlatforms_FullMethodName = "/hyapp.game.v1.GameAdminService/ListPlatforms"
|
|
GameAdminService_UpsertPlatform_FullMethodName = "/hyapp.game.v1.GameAdminService/UpsertPlatform"
|
|
GameAdminService_ListCatalog_FullMethodName = "/hyapp.game.v1.GameAdminService/ListCatalog"
|
|
GameAdminService_UpsertCatalog_FullMethodName = "/hyapp.game.v1.GameAdminService/UpsertCatalog"
|
|
GameAdminService_SetGameStatus_FullMethodName = "/hyapp.game.v1.GameAdminService/SetGameStatus"
|
|
GameAdminService_DeleteCatalog_FullMethodName = "/hyapp.game.v1.GameAdminService/DeleteCatalog"
|
|
)
|
|
|
|
// GameAdminServiceClient is the client API for GameAdminService 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 GameAdminServiceClient interface {
|
|
ListPlatforms(ctx context.Context, in *ListPlatformsRequest, opts ...grpc.CallOption) (*ListPlatformsResponse, error)
|
|
UpsertPlatform(ctx context.Context, in *UpsertPlatformRequest, opts ...grpc.CallOption) (*PlatformResponse, error)
|
|
ListCatalog(ctx context.Context, in *ListCatalogRequest, opts ...grpc.CallOption) (*ListCatalogResponse, error)
|
|
UpsertCatalog(ctx context.Context, in *UpsertCatalogRequest, opts ...grpc.CallOption) (*CatalogResponse, error)
|
|
SetGameStatus(ctx context.Context, in *SetGameStatusRequest, opts ...grpc.CallOption) (*CatalogResponse, error)
|
|
DeleteCatalog(ctx context.Context, in *DeleteCatalogRequest, opts ...grpc.CallOption) (*DeleteCatalogResponse, error)
|
|
}
|
|
|
|
type gameAdminServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewGameAdminServiceClient(cc grpc.ClientConnInterface) GameAdminServiceClient {
|
|
return &gameAdminServiceClient{cc}
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) ListPlatforms(ctx context.Context, in *ListPlatformsRequest, opts ...grpc.CallOption) (*ListPlatformsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListPlatformsResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_ListPlatforms_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) UpsertPlatform(ctx context.Context, in *UpsertPlatformRequest, opts ...grpc.CallOption) (*PlatformResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(PlatformResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_UpsertPlatform_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) ListCatalog(ctx context.Context, in *ListCatalogRequest, opts ...grpc.CallOption) (*ListCatalogResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListCatalogResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_ListCatalog_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) UpsertCatalog(ctx context.Context, in *UpsertCatalogRequest, opts ...grpc.CallOption) (*CatalogResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CatalogResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_UpsertCatalog_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) SetGameStatus(ctx context.Context, in *SetGameStatusRequest, opts ...grpc.CallOption) (*CatalogResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CatalogResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_SetGameStatus_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *gameAdminServiceClient) DeleteCatalog(ctx context.Context, in *DeleteCatalogRequest, opts ...grpc.CallOption) (*DeleteCatalogResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteCatalogResponse)
|
|
err := c.cc.Invoke(ctx, GameAdminService_DeleteCatalog_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GameAdminServiceServer is the server API for GameAdminService service.
|
|
// All implementations must embed UnimplementedGameAdminServiceServer
|
|
// for forward compatibility.
|
|
type GameAdminServiceServer interface {
|
|
ListPlatforms(context.Context, *ListPlatformsRequest) (*ListPlatformsResponse, error)
|
|
UpsertPlatform(context.Context, *UpsertPlatformRequest) (*PlatformResponse, error)
|
|
ListCatalog(context.Context, *ListCatalogRequest) (*ListCatalogResponse, error)
|
|
UpsertCatalog(context.Context, *UpsertCatalogRequest) (*CatalogResponse, error)
|
|
SetGameStatus(context.Context, *SetGameStatusRequest) (*CatalogResponse, error)
|
|
DeleteCatalog(context.Context, *DeleteCatalogRequest) (*DeleteCatalogResponse, error)
|
|
mustEmbedUnimplementedGameAdminServiceServer()
|
|
}
|
|
|
|
// UnimplementedGameAdminServiceServer 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 UnimplementedGameAdminServiceServer struct{}
|
|
|
|
func (UnimplementedGameAdminServiceServer) ListPlatforms(context.Context, *ListPlatformsRequest) (*ListPlatformsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListPlatforms not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) UpsertPlatform(context.Context, *UpsertPlatformRequest) (*PlatformResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method UpsertPlatform not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) ListCatalog(context.Context, *ListCatalogRequest) (*ListCatalogResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListCatalog not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) UpsertCatalog(context.Context, *UpsertCatalogRequest) (*CatalogResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method UpsertCatalog not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) SetGameStatus(context.Context, *SetGameStatusRequest) (*CatalogResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetGameStatus not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) DeleteCatalog(context.Context, *DeleteCatalogRequest) (*DeleteCatalogResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteCatalog not implemented")
|
|
}
|
|
func (UnimplementedGameAdminServiceServer) mustEmbedUnimplementedGameAdminServiceServer() {}
|
|
func (UnimplementedGameAdminServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeGameAdminServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to GameAdminServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeGameAdminServiceServer interface {
|
|
mustEmbedUnimplementedGameAdminServiceServer()
|
|
}
|
|
|
|
func RegisterGameAdminServiceServer(s grpc.ServiceRegistrar, srv GameAdminServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedGameAdminServiceServer 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(&GameAdminService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _GameAdminService_ListPlatforms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListPlatformsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).ListPlatforms(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_ListPlatforms_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).ListPlatforms(ctx, req.(*ListPlatformsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAdminService_UpsertPlatform_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UpsertPlatformRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).UpsertPlatform(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_UpsertPlatform_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).UpsertPlatform(ctx, req.(*UpsertPlatformRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAdminService_ListCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListCatalogRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).ListCatalog(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_ListCatalog_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).ListCatalog(ctx, req.(*ListCatalogRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAdminService_UpsertCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UpsertCatalogRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).UpsertCatalog(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_UpsertCatalog_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).UpsertCatalog(ctx, req.(*UpsertCatalogRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAdminService_SetGameStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetGameStatusRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).SetGameStatus(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_SetGameStatus_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).SetGameStatus(ctx, req.(*SetGameStatusRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GameAdminService_DeleteCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteCatalogRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GameAdminServiceServer).DeleteCatalog(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: GameAdminService_DeleteCatalog_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GameAdminServiceServer).DeleteCatalog(ctx, req.(*DeleteCatalogRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// GameAdminService_ServiceDesc is the grpc.ServiceDesc for GameAdminService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var GameAdminService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "hyapp.game.v1.GameAdminService",
|
|
HandlerType: (*GameAdminServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "ListPlatforms",
|
|
Handler: _GameAdminService_ListPlatforms_Handler,
|
|
},
|
|
{
|
|
MethodName: "UpsertPlatform",
|
|
Handler: _GameAdminService_UpsertPlatform_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListCatalog",
|
|
Handler: _GameAdminService_ListCatalog_Handler,
|
|
},
|
|
{
|
|
MethodName: "UpsertCatalog",
|
|
Handler: _GameAdminService_UpsertCatalog_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetGameStatus",
|
|
Handler: _GameAdminService_SetGameStatus_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteCatalog",
|
|
Handler: _GameAdminService_DeleteCatalog_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "proto/game/v1/game.proto",
|
|
}
|