protobuf-platform 1.0.238 → 1.0.240

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobuf-platform",
-  "version": "1.0.238",
+  "version": "1.0.240",
   "description": "Protobuf structures",
   "main": "index.js",
   "scripts": {

package/tournament/tournament.proto

@@ -4,12 +4,81 @@ package tournament;
 
 service Tournament {
     rpc checkConnection(PingRequest) returns (PongResponse);
+    rpc getMediaResource(GetFileRequest) returns (stream File);
+    //Tournaments
+    rpc createSingleTournament(stream TournamentRequest) returns (TournamentResponse);
+    rpc readSingleTournament(GetTournamentRequest) returns (TournamentResponse);
+    rpc updateSingleTournament(stream TournamentRequest) returns (TournamentResponse);
+    rpc deleteSingleTournament(GetTournamentRequest) returns (TournamentStatusResponse);
+    rpc readListTournaments(PaginationRequest) returns (TournamentItemsResponse);
+    //Tournament Statuses
+    rpc readListTournamentStatuses(PaginationRequest) returns (TournamentStatusItemsResponse);
 }
+//Technical
 message PingRequest { string ping = 1; }
 message PongResponse { string pong = 1; }
+//Media
+message File { bytes media = 1; optional string file_name = 2; optional string file_type = 3; }
+message GetFileRequest { string file_name = 1; string instance_type = 2; }
 message PaginationRequest { int32 limit = 1; int32 offset = 2; optional UserSearchRequest user_search_params = 3; }
 message UserSearchRequest {
     optional int32 user_id = 1;
     optional string balance_type = 2;
     optional string currency = 3;
-}
+}
+//Tournament CRUD | Requests
+message TournamentItem {
+    optional int32 id = 1;
+    optional string title = 2;
+    optional string description = 3;
+    optional int32 is_active = 4;
+    optional int32 current_members_count = 5;
+    optional int32 max_members_count = 6;
+    optional string started_at = 7;
+    optional string finished_at = 8;
+    optional string status = 9;
+    optional string image = 10;
+}
+message TournamentRequest {
+    oneof request {
+        TournamentItemRequest tournament_data = 1;
+        File file = 2;
+    }
+}
+message TournamentItemRequest {
+    optional int32 id = 1;
+    optional string title = 2;
+    optional string description = 3;
+    optional int32 is_active = 4;
+    optional int32 max_members_count = 5;
+    optional string started_at = 6;
+    optional string finished_at = 7;
+    optional int32 status_id = 8;
+}
+message GetTournamentRequest {
+    int32 id = 1;
+}
+//Tournament CRUD | Responses
+message TournamentResponse {
+    TournamentItem data = 1;
+}
+message TournamentItemsResponse {
+    repeated TournamentItem items = 1;
+    optional int32 total_pages = 2;
+    optional int32 total_items = 3;
+}
+message TournamentStatusResponse {
+    string status = 1;
+}
+message TournamentStatusItem {
+    int32 id = 1;
+    string title = 2;
+    optional bool is_active = 3;
+    optional string description = 4;
+}
+message TournamentStatusItemsResponse {
+    repeated TournamentStatusItem items = 1;
+    optional int32 total_pages = 2;
+    optional int32 total_items = 3;
+}
+

package/tournament/tournament_grpc_pb.js

@@ -4,6 +4,50 @@
 var grpc = require('@grpc/grpc-js');
 var tournament_pb = require('./tournament_pb.js');
 
+function serialize_tournament_File(arg) {
+  if (!(arg instanceof tournament_pb.File)) {
+    throw new Error('Expected argument of type tournament.File');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_File(buffer_arg) {
+  return tournament_pb.File.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_GetFileRequest(arg) {
+  if (!(arg instanceof tournament_pb.GetFileRequest)) {
+    throw new Error('Expected argument of type tournament.GetFileRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_GetFileRequest(buffer_arg) {
+  return tournament_pb.GetFileRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_GetTournamentRequest(arg) {
+  if (!(arg instanceof tournament_pb.GetTournamentRequest)) {
+    throw new Error('Expected argument of type tournament.GetTournamentRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_GetTournamentRequest(buffer_arg) {
+  return tournament_pb.GetTournamentRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_PaginationRequest(arg) {
+  if (!(arg instanceof tournament_pb.PaginationRequest)) {
+    throw new Error('Expected argument of type tournament.PaginationRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_PaginationRequest(buffer_arg) {
+  return tournament_pb.PaginationRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_tournament_PingRequest(arg) {
   if (!(arg instanceof tournament_pb.PingRequest)) {
     throw new Error('Expected argument of type tournament.PingRequest');
@@ -26,6 +70,61 @@ function deserialize_tournament_PongResponse(buffer_arg) {
   return tournament_pb.PongResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_tournament_TournamentItemsResponse(arg) {
+  if (!(arg instanceof tournament_pb.TournamentItemsResponse)) {
+    throw new Error('Expected argument of type tournament.TournamentItemsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_TournamentItemsResponse(buffer_arg) {
+  return tournament_pb.TournamentItemsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_TournamentRequest(arg) {
+  if (!(arg instanceof tournament_pb.TournamentRequest)) {
+    throw new Error('Expected argument of type tournament.TournamentRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_TournamentRequest(buffer_arg) {
+  return tournament_pb.TournamentRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_TournamentResponse(arg) {
+  if (!(arg instanceof tournament_pb.TournamentResponse)) {
+    throw new Error('Expected argument of type tournament.TournamentResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_TournamentResponse(buffer_arg) {
+  return tournament_pb.TournamentResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_TournamentStatusItemsResponse(arg) {
+  if (!(arg instanceof tournament_pb.TournamentStatusItemsResponse)) {
+    throw new Error('Expected argument of type tournament.TournamentStatusItemsResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_TournamentStatusItemsResponse(buffer_arg) {
+  return tournament_pb.TournamentStatusItemsResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_tournament_TournamentStatusResponse(arg) {
+  if (!(arg instanceof tournament_pb.TournamentStatusResponse)) {
+    throw new Error('Expected argument of type tournament.TournamentStatusResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_tournament_TournamentStatusResponse(buffer_arg) {
+  return tournament_pb.TournamentStatusResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 
 var TournamentService = exports.TournamentService = {
   checkConnection: {
@@ -39,6 +138,85 @@ var TournamentService = exports.TournamentService = {
     responseSerialize: serialize_tournament_PongResponse,
     responseDeserialize: deserialize_tournament_PongResponse,
   },
+  getMediaResource: {
+    path: '/tournament.Tournament/getMediaResource',
+    requestStream: false,
+    responseStream: true,
+    requestType: tournament_pb.GetFileRequest,
+    responseType: tournament_pb.File,
+    requestSerialize: serialize_tournament_GetFileRequest,
+    requestDeserialize: deserialize_tournament_GetFileRequest,
+    responseSerialize: serialize_tournament_File,
+    responseDeserialize: deserialize_tournament_File,
+  },
+  // Tournaments
+createSingleTournament: {
+    path: '/tournament.Tournament/createSingleTournament',
+    requestStream: true,
+    responseStream: false,
+    requestType: tournament_pb.TournamentRequest,
+    responseType: tournament_pb.TournamentResponse,
+    requestSerialize: serialize_tournament_TournamentRequest,
+    requestDeserialize: deserialize_tournament_TournamentRequest,
+    responseSerialize: serialize_tournament_TournamentResponse,
+    responseDeserialize: deserialize_tournament_TournamentResponse,
+  },
+  readSingleTournament: {
+    path: '/tournament.Tournament/readSingleTournament',
+    requestStream: false,
+    responseStream: false,
+    requestType: tournament_pb.GetTournamentRequest,
+    responseType: tournament_pb.TournamentResponse,
+    requestSerialize: serialize_tournament_GetTournamentRequest,
+    requestDeserialize: deserialize_tournament_GetTournamentRequest,
+    responseSerialize: serialize_tournament_TournamentResponse,
+    responseDeserialize: deserialize_tournament_TournamentResponse,
+  },
+  updateSingleTournament: {
+    path: '/tournament.Tournament/updateSingleTournament',
+    requestStream: true,
+    responseStream: false,
+    requestType: tournament_pb.TournamentRequest,
+    responseType: tournament_pb.TournamentResponse,
+    requestSerialize: serialize_tournament_TournamentRequest,
+    requestDeserialize: deserialize_tournament_TournamentRequest,
+    responseSerialize: serialize_tournament_TournamentResponse,
+    responseDeserialize: deserialize_tournament_TournamentResponse,
+  },
+  deleteSingleTournament: {
+    path: '/tournament.Tournament/deleteSingleTournament',
+    requestStream: false,
+    responseStream: false,
+    requestType: tournament_pb.GetTournamentRequest,
+    responseType: tournament_pb.TournamentStatusResponse,
+    requestSerialize: serialize_tournament_GetTournamentRequest,
+    requestDeserialize: deserialize_tournament_GetTournamentRequest,
+    responseSerialize: serialize_tournament_TournamentStatusResponse,
+    responseDeserialize: deserialize_tournament_TournamentStatusResponse,
+  },
+  readListTournaments: {
+    path: '/tournament.Tournament/readListTournaments',
+    requestStream: false,
+    responseStream: false,
+    requestType: tournament_pb.PaginationRequest,
+    responseType: tournament_pb.TournamentItemsResponse,
+    requestSerialize: serialize_tournament_PaginationRequest,
+    requestDeserialize: deserialize_tournament_PaginationRequest,
+    responseSerialize: serialize_tournament_TournamentItemsResponse,
+    responseDeserialize: deserialize_tournament_TournamentItemsResponse,
+  },
+  // Tournament Statuses
+readListTournamentStatuses: {
+    path: '/tournament.Tournament/readListTournamentStatuses',
+    requestStream: false,
+    responseStream: false,
+    requestType: tournament_pb.PaginationRequest,
+    responseType: tournament_pb.TournamentStatusItemsResponse,
+    requestSerialize: serialize_tournament_PaginationRequest,
+    requestDeserialize: deserialize_tournament_PaginationRequest,
+    responseSerialize: serialize_tournament_TournamentStatusItemsResponse,
+    responseDeserialize: deserialize_tournament_TournamentStatusItemsResponse,
+  },
 };
 
 exports.TournamentClient = grpc.makeGenericClientConstructor(TournamentService);