jp.db.schemas 2.0.1 → 2.0.3

package/dist/schemas/tournament_one_table_rooms.schema.d.ts

@@ -0,0 +1,237 @@
+import { Document, HydratedDocument } from 'mongoose';
+import { ITournamentWinner } from '../models/tournament-winner.interface';
+import { ITournamentParticipant } from '../models/tournament-participant.interface';
+export type TournamentOneTableRoomDocument = HydratedDocument<TournamentOneTableRoom>;
+export declare class TournamentOneTableRoom {
+    readonly tournamentId: string;
+    title: Record<string, string>;
+    subtitle: Record<string, string>;
+    tableSize: number;
+    bet: number;
+    ticketPrice: number;
+    roomType: string;
+    gameType: string;
+    rulesType: string;
+    deckType?: string;
+    isTemplate: boolean;
+    templateId?: string;
+    type: string;
+    description: Record<string, string>;
+    maxParticipants: number;
+    participants: Array<ITournamentParticipant>;
+    status: string;
+    winners: Array<ITournamentWinner>;
+    createDate: Date;
+    startDate: Date;
+    finishDate: Date;
+}
+export declare const TournamentOneTableRoomSchema: import("mongoose").Schema<TournamentOneTableRoom, import("mongoose").Model<TournamentOneTableRoom, any, any, any, (Document<unknown, any, TournamentOneTableRoom, any, import("mongoose").DefaultSchemaOptions> & TournamentOneTableRoom & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}) | (Document<unknown, any, TournamentOneTableRoom, any, import("mongoose").DefaultSchemaOptions> & TournamentOneTableRoom & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}), any, TournamentOneTableRoom>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    readonly tournamentId?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    title?: import("mongoose").SchemaDefinitionProperty<Record<string, string>, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    subtitle?: import("mongoose").SchemaDefinitionProperty<Record<string, string>, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    tableSize?: import("mongoose").SchemaDefinitionProperty<number, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    bet?: import("mongoose").SchemaDefinitionProperty<number, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    ticketPrice?: import("mongoose").SchemaDefinitionProperty<number, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    roomType?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    gameType?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    rulesType?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    deckType?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    isTemplate?: import("mongoose").SchemaDefinitionProperty<boolean, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    templateId?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    type?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    description?: import("mongoose").SchemaDefinitionProperty<Record<string, string>, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    maxParticipants?: import("mongoose").SchemaDefinitionProperty<number, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    participants?: import("mongoose").SchemaDefinitionProperty<ITournamentParticipant[], TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    status?: import("mongoose").SchemaDefinitionProperty<string, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    winners?: import("mongoose").SchemaDefinitionProperty<ITournamentWinner[], TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    createDate?: import("mongoose").SchemaDefinitionProperty<Date, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    startDate?: import("mongoose").SchemaDefinitionProperty<Date, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    finishDate?: import("mongoose").SchemaDefinitionProperty<Date, TournamentOneTableRoom, Document<unknown, {}, TournamentOneTableRoom, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TournamentOneTableRoom & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+}, TournamentOneTableRoom>;
+//# sourceMappingURL=tournament_one_table_rooms.schema.d.ts.map

package/dist/schemas/tournament_one_table_rooms.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament_one_table_rooms.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/tournament_one_table_rooms.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEpF,MAAM,MAAM,8BAA8B,GAAG,gBAAgB,CAAC,sBAAsB,CAAC,CAAC;AAEtF,qBACa,sBAAsB;IAM/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAG9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAG9B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAGjC,SAAS,EAAE,MAAM,CAAC;IAGlB,GAAG,EAAE,MAAM,CAAC;IAGZ,WAAW,EAAE,MAAM,CAAC;IAGpB,QAAQ,EAAE,MAAM,CAAC;IAGjB,QAAQ,EAAE,MAAM,CAAC;IAGjB,SAAS,EAAE,MAAM,CAAC;IAGlB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAKlB,UAAU,EAAE,OAAO,CAAC;IAGpB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,IAAI,EAAE,MAAM,CAAC;IAGb,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAGpC,eAAe,EAAE,MAAM,CAAC;IAGxB,YAAY,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAG5C,MAAM,EAAE,MAAM,CAAC;IAGf,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAGlC,UAAU,EAAE,IAAI,CAAC;IAGjB,SAAS,EAAE,IAAI,CAAC;IAGhB,UAAU,EAAE,IAAI,CAAC;CACpB;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAuD,CAAC"}

package/dist/schemas/tournament_one_table_rooms.schema.js

@@ -0,0 +1,109 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TournamentOneTableRoomSchema = exports.TournamentOneTableRoom = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+let TournamentOneTableRoom = class TournamentOneTableRoom {
+};
+exports.TournamentOneTableRoom = TournamentOneTableRoom;
+__decorate([
+    (0, mongoose_1.Virtual)({
+        get: function () {
+            return this._id.toString();
+        },
+    }),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "tournamentId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: Object }),
+    __metadata("design:type", Object)
+], TournamentOneTableRoom.prototype, "title", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: Object }),
+    __metadata("design:type", Object)
+], TournamentOneTableRoom.prototype, "subtitle", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], TournamentOneTableRoom.prototype, "tableSize", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], TournamentOneTableRoom.prototype, "bet", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], TournamentOneTableRoom.prototype, "ticketPrice", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "roomType", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "gameType", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "rulesType", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "deckType", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Boolean)
+], TournamentOneTableRoom.prototype, "isTemplate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "templateId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "type", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ type: Object }),
+    __metadata("design:type", Object)
+], TournamentOneTableRoom.prototype, "description", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], TournamentOneTableRoom.prototype, "maxParticipants", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Array)
+], TournamentOneTableRoom.prototype, "participants", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], TournamentOneTableRoom.prototype, "status", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Array)
+], TournamentOneTableRoom.prototype, "winners", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], TournamentOneTableRoom.prototype, "createDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], TournamentOneTableRoom.prototype, "startDate", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Date)
+], TournamentOneTableRoom.prototype, "finishDate", void 0);
+exports.TournamentOneTableRoom = TournamentOneTableRoom = __decorate([
+    (0, mongoose_1.Schema)({ collection: 'tournament_one_table_rooms' })
+], TournamentOneTableRoom);
+exports.TournamentOneTableRoomSchema = mongoose_1.SchemaFactory.createForClass(TournamentOneTableRoom);
+//# sourceMappingURL=tournament_one_table_rooms.schema.js.map

package/dist/schemas/tournament_one_table_rooms.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tournament_one_table_rooms.schema.js","sourceRoot":"","sources":["../../src/schemas/tournament_one_table_rooms.schema.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwE;AASjE,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB;CAqElC,CAAA;AArEY,wDAAsB;AAMtB;IALR,IAAA,kBAAO,EAAC;QACL,GAAG,EAAE;YACD,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;KACJ,CAAC;;4DAC4B;AAG9B;IADC,IAAA,eAAI,EAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;;qDACO;AAG9B;IADC,IAAA,eAAI,EAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;;wDACU;AAGjC;IADC,IAAA,eAAI,GAAE;;yDACW;AAGlB;IADC,IAAA,eAAI,GAAE;;mDACK;AAGZ;IADC,IAAA,eAAI,GAAE;;2DACa;AAGpB;IADC,IAAA,eAAI,GAAE;;wDACU;AAGjB;IADC,IAAA,eAAI,GAAE;;wDACU;AAGjB;IADC,IAAA,eAAI,GAAE;;yDACW;AAGlB;IADC,IAAA,eAAI,GAAE;;wDACW;AAKlB;IADC,IAAA,eAAI,GAAE;;0DACa;AAGpB;IADC,IAAA,eAAI,GAAE;;0DACa;AAGpB;IADC,IAAA,eAAI,GAAE;;oDACM;AAGb;IADC,IAAA,eAAI,EAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;;2DACa;AAGpC;IADC,IAAA,eAAI,GAAE;;+DACiB;AAGxB;IADC,IAAA,eAAI,GAAE;8BACO,KAAK;4DAAyB;AAG5C;IADC,IAAA,eAAI,GAAE;;sDACQ;AAGf;IADC,IAAA,eAAI,GAAE;8BACE,KAAK;uDAAoB;AAGlC;IADC,IAAA,eAAI,GAAE;8BACK,IAAI;0DAAC;AAGjB;IADC,IAAA,eAAI,GAAE;8BACI,IAAI;yDAAC;AAGhB;IADC,IAAA,eAAI,GAAE;8BACK,IAAI;0DAAC;iCApER,sBAAsB;IADlC,IAAA,iBAAM,EAAC,EAAE,UAAU,EAAE,4BAA4B,EAAE,CAAC;GACxC,sBAAsB,CAqElC;AAEY,QAAA,4BAA4B,GAAG,wBAAa,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.db.schemas",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -50,6 +50,12 @@ import { GameResult, GameResultSchema } from './schemas/game_result.schema';
 import type { GameResultDocument } from './schemas/game_result.schema';
 import { BalanceHistory, BalanceHistorySchema } from './schemas/balance_history.schema';
 import type { BalanceHistoryDocument } from './schemas/balance_history.schema';
+import { SimpleRoom, SimpleRoomSchema } from './schemas/simple_rooms.schema';
+import type { SimpleRoomDocument } from './schemas/simple_rooms.schema';
+import { TournamentOneTableRoom, TournamentOneTableRoomSchema, } from './schemas/tournament_one_table_rooms.schema';
+import type { TournamentOneTableRoomDocument } from './schemas/tournament_one_table_rooms.schema';
+import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema } from './schemas/tournament_many_tables_rooms.schema';
+import type { TournamentManyTablesRoomDocument } from './schemas/tournament_many_tables_rooms.schema';
 
 import {
     AdminRepository,
@@ -65,6 +71,9 @@ import {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
 } from './repositories'
 
 export type {
@@ -94,6 +103,9 @@ export type {
     MenuDocument,
     GameResultDocument,
     BalanceHistoryDocument,
+    SimpleRoomDocument,
+    TournamentOneTableRoomDocument,
+    TournamentManyTablesRoomDocument,
 }
 
 export {
@@ -149,6 +161,12 @@ export {
     GameResultSchema,
     BalanceHistory,
     BalanceHistorySchema,
+    SimpleRoom,
+    SimpleRoomSchema,
+    TournamentOneTableRoom,
+    TournamentOneTableRoomSchema,
+    TournamentManyTablesRoom,
+    TournamentManyTablesRoomSchema,
 }
 
 export {
@@ -165,4 +183,7 @@ export {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
 }

package/src/models/tournament-participant.interface.ts

@@ -0,0 +1,5 @@
+export interface ITournamentParticipant {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+}

package/src/models/tournament-status.enum.ts

@@ -0,0 +1,6 @@
+export enum TournamentStatusEnum {
+    STATE_WAITING_FOR_START = 'STATE_WAITING_FOR_START',
+    STATE_IN_PROGRESS = 'STATE_IN_PROGRESS',
+    STATE_FINISHED = 'STATE_FINISHED',
+    STATE_CANCELLED = 'STATE_CANCELLED',
+}

package/src/models/tournament-winner.interface.ts

@@ -0,0 +1,7 @@
+export interface ITournamentWinner {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+    profit: number;
+    rank: number;
+}

package/src/repositories/index.ts

@@ -11,6 +11,9 @@ import { MenuRepository } from './menu.repository';
 import { RoomsRepository } from './rooms.repository';
 import { GameResultRepository } from './game-result.repository';
 import { BalanceHistoryRepository } from './balance-history.repository';
+import { SimpleRoomsRepository } from './simple-rooms.repository';
+import { TournamentOneTableRoomsRepository } from './tournament-one-table-rooms.repository';
+import { TournamentManyTablesRoomsRepository } from './tournament-many-tables-rooms.repository';
 
 export {
     AdminRepository,
@@ -26,4 +29,7 @@ export {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
 }

package/src/repositories/simple-rooms.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { SimpleRoom, SimpleRoomDocument } from '../';
+
+@Injectable()
+export class SimpleRoomsRepository {
+    constructor (@InjectModel(SimpleRoom.name) private roomModel: Model<SimpleRoomDocument>) {
+    }
+
+    async findRooms (gameType: string): Promise<Array<SimpleRoomDocument>> {
+        return this.roomModel
+            .find({ gameType })
+            .exec();
+    }
+}

package/src/repositories/tournament-many-tables-rooms.repository.ts

@@ -0,0 +1,89 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import {
+    Notification,
+    TournamentManyTablesRoom,
+    TournamentManyTablesRoomDocument, TournamentOneTableRoomDocument,
+} from '../';
+import { ITournamentParticipant } from '../models/tournament-participant.interface';
+import { TournamentStatusEnum } from '../models/tournament-status.enum';
+import { ITournamentWinner } from '../models/tournament-winner.interface';
+
+@Injectable()
+export class TournamentManyTablesRoomsRepository {
+    constructor (@InjectModel(TournamentManyTablesRoom.name) private tournamentModel: Model<TournamentManyTablesRoomDocument>) {
+    }
+
+    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({ templateId, gameType })
+            .exec();
+    }
+
+    async findTournamentById (tournamentId: string): Promise<TournamentManyTablesRoomDocument | null> {
+        return this.tournamentModel
+            .findById(tournamentId)
+            .exec();
+    }
+
+    async findTournaments (gameType: string): Promise<Array<TournamentManyTablesRoomDocument>> {
+        return this.tournamentModel
+            .find({ gameType, isTemplate: false })
+            .exec();
+    }
+
+    async createTournament (tournament: Partial<TournamentManyTablesRoom>): Promise<TournamentManyTablesRoomDocument> {
+        return this.tournamentModel.create(tournament)
+    }
+
+    async updateTournament (tournamentId: string, tournament: Partial<TournamentManyTablesRoom>): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    ...tournament,
+                },
+            }).exec();
+    }
+
+    public async removeTournament (tournamentId: string): Promise<void> {
+        await this.tournamentModel.findByIdAndDelete(tournamentId);
+    }
+
+    async startTournament (tournamentId: string, participants: Array<ITournamentParticipant>): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    startDate: new Date(),
+                    status: TournamentStatusEnum.STATE_IN_PROGRESS,
+                    participants,
+                },
+            }).exec();
+    }
+
+    async cancelTournament (tournamentId: string): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    finishDate: new Date(),
+                    status: TournamentStatusEnum.STATE_CANCELLED,
+                },
+            }).exec();
+    }
+
+    async finishTournament (tournamentId: string, winners: Array<ITournamentWinner>): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    finishDate: new Date(),
+                    status: TournamentStatusEnum.STATE_FINISHED,
+                    winners,
+                },
+            }).exec();
+    }
+}

package/src/repositories/tournament-one-table-rooms.repository.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { TournamentOneTableRoom, TournamentOneTableRoomDocument } from '../';
+import { ITournamentParticipant } from '../models/tournament-participant.interface';
+import { TournamentStatusEnum } from '../models/tournament-status.enum';
+import { ITournamentWinner } from '../models/tournament-winner.interface';
+
+@Injectable()
+export class TournamentOneTableRoomsRepository {
+    constructor (@InjectModel(TournamentOneTableRoom.name) private tournamentModel: Model<TournamentOneTableRoomDocument>) {
+    }
+
+    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({ templateId, gameType })
+            .exec();
+    }
+
+    async findTournamentById (tournamentId: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findById(tournamentId)
+            .exec();
+    }
+
+    async findTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
+        return this.tournamentModel
+            .find({ gameType, isTemplate: false })
+            .exec();
+    }
+
+    async createTournament (tournament: Partial<TournamentOneTableRoom>): Promise<TournamentOneTableRoomDocument> {
+        return this.tournamentModel.create(tournament)
+    }
+
+    async startTournament (tournamentId: string, participants: Array<ITournamentParticipant>): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    startDate: new Date(),
+                    status: TournamentStatusEnum.STATE_IN_PROGRESS,
+                    participants,
+                },
+            }).exec();
+    }
+
+    async cancelTournament (tournamentId: string): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    finishDate: new Date(),
+                    status: TournamentStatusEnum.STATE_CANCELLED,
+                },
+            }).exec();
+    }
+
+    async finishTournament (tournamentId: string, winners: Array<ITournamentWinner>): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    finishDate: new Date(),
+                    status: TournamentStatusEnum.STATE_FINISHED,
+                    winners,
+                },
+            }).exec();
+    }
+}