jp.db.schemas 2.1.15 → 2.2.0

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

@@ -1,132 +1,132 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import {
-    TournamentManyTablesRoom,
-    TournamentManyTablesRoomDocument,
-    TournamentOneTableRoomDocument,
-} from '../';
-import { TournamentStatusEnum } from '../models/tournament-status.enum';
-import { ITournamentWinner } from '../models/tournament-winner.interface';
-import { TournamentTemplateEnum } from '../models/tournament-template.enum';
-import { ITournamentParticipant } from '../models/tournament-participant.interface';
-
-@Injectable()
-export class TournamentManyTablesRoomsRepository {
-    constructor (@InjectModel(TournamentManyTablesRoom.name) private tournamentModel: Model<TournamentManyTablesRoomDocument>) {
-    }
-
-    async findTournamentById (tournamentId: string): Promise<TournamentManyTablesRoomDocument | null> {
-        return this.tournamentModel
-            .findById(tournamentId)
-            .exec();
-    }
-
-    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findOne({ templateId, gameType })
-            .exec();
-    }
-
-    async findTournaments (gameType: string): Promise<Array<TournamentManyTablesRoomDocument>> {
-        return this.tournamentModel
-            .find({ gameType, isTemplate: false })
-            .exec();
-    }
-
-    async findWaitingTournamentByDate (gameType: string, startDate: Date, endDate: Date): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findOne({
-                gameType,
-                status: TournamentStatusEnum.STATE_WAITING_FOR_START,
-                isTemplate: false,
-                scheduleDate: { $gte: startDate, $lt: endDate },
-            })
-            .exec();
-    }
-
-    async createTournament (tournament: Partial<TournamentManyTablesRoom>): Promise<TournamentManyTablesRoomDocument> {
-        return this.tournamentModel.create(tournament)
-    }
-
-    async scheduleTournamentFromMasterTemplate (gameType: string, scheduleDate: Date): Promise<TournamentManyTablesRoomDocument> {
-        const masterTemplate = await this.findTemplateById(TournamentTemplateEnum.MASTER, gameType);
-
-        return this.createTournament({
-            title: masterTemplate.title,
-            subtitle: masterTemplate.subtitle,
-            description: masterTemplate.description,
-            tableSize: masterTemplate.tableSize,
-            bet: masterTemplate.bet,
-            ticketPrice: masterTemplate.ticketPrice,
-            roomType: masterTemplate.roomType,
-            gameType: masterTemplate.gameType,
-            rulesType: masterTemplate.rulesType,
-            deckType: masterTemplate.deckType,
-            maxParticipants: masterTemplate.maxParticipants,
-            participants: masterTemplate.participants,
-            status: masterTemplate.status,
-            winners: masterTemplate.winners,
-            createDate: new Date(),
-            isTemplate: false,
-            templateId: undefined,
-            scheduleDate,
-        });
-    }
-
-    async updateTournament (tournamentId: string, tournament: Partial<TournamentManyTablesRoom>): Promise<TournamentManyTablesRoomDocument> {
-        return this.tournamentModel.findByIdAndUpdate(
-            tournamentId,
-            {
-                $set: {
-                    ...tournament,
-                },
-            }).exec();
-    }
-
-    async removeTournament (tournamentId: string): Promise<void> {
-        await this.tournamentModel.findByIdAndDelete(tournamentId);
-    }
-
-    async startTournament (tournamentId: string): Promise<void> {
-        await this.tournamentModel.findByIdAndUpdate(
-            tournamentId,
-            {
-                $set: {
-                    startDate: new Date(),
-                    status: TournamentStatusEnum.STATE_IN_PROGRESS,
-                },
-            }).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();
-    }
-
-    async addPlayerToParticipants (tournamentId: string, player: ITournamentParticipant): Promise<void> {
-        await this.tournamentModel.findByIdAndUpdate(
-            tournamentId,
-            { $push: { participants: player } })
-            .exec();
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import {
+    TournamentManyTablesRoom,
+    TournamentManyTablesRoomDocument,
+    TournamentOneTableRoomDocument,
+} from '../';
+import { TournamentStatusEnum } from '../models/tournament-status.enum';
+import { ITournamentWinner } from '../models/tournament-winner.interface';
+import { TournamentTemplateEnum } from '../models/tournament-template.enum';
+import { ITournamentParticipant } from '../models/tournament-participant.interface';
+
+@Injectable()
+export class TournamentManyTablesRoomsRepository {
+    constructor (@InjectModel(TournamentManyTablesRoom.name) private tournamentModel: Model<TournamentManyTablesRoomDocument>) {
+    }
+
+    async findTournamentById (tournamentId: string): Promise<TournamentManyTablesRoomDocument | null> {
+        return this.tournamentModel
+            .findById(tournamentId)
+            .exec();
+    }
+
+    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({ templateId, gameType })
+            .exec();
+    }
+
+    async findTournaments (gameType: string): Promise<Array<TournamentManyTablesRoomDocument>> {
+        return this.tournamentModel
+            .find({ gameType, isTemplate: false })
+            .exec();
+    }
+
+    async findWaitingTournamentByDate (gameType: string, startDate: Date, endDate: Date): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({
+                gameType,
+                status: TournamentStatusEnum.STATE_WAITING_FOR_START,
+                isTemplate: false,
+                scheduleDate: { $gte: startDate, $lt: endDate },
+            })
+            .exec();
+    }
+
+    async createTournament (tournament: Partial<TournamentManyTablesRoom>): Promise<TournamentManyTablesRoomDocument> {
+        return this.tournamentModel.create(tournament)
+    }
+
+    async scheduleTournamentFromMasterTemplate (gameType: string, scheduleDate: Date): Promise<TournamentManyTablesRoomDocument> {
+        const masterTemplate = await this.findTemplateById(TournamentTemplateEnum.MASTER, gameType);
+
+        return this.createTournament({
+            title: masterTemplate.title,
+            subtitle: masterTemplate.subtitle,
+            description: masterTemplate.description,
+            tableSize: masterTemplate.tableSize,
+            bet: masterTemplate.bet,
+            ticketPrice: masterTemplate.ticketPrice,
+            roomType: masterTemplate.roomType,
+            gameType: masterTemplate.gameType,
+            rulesType: masterTemplate.rulesType,
+            deckType: masterTemplate.deckType,
+            maxParticipants: masterTemplate.maxParticipants,
+            participants: masterTemplate.participants,
+            status: masterTemplate.status,
+            winners: masterTemplate.winners,
+            createDate: new Date(),
+            isTemplate: false,
+            templateId: undefined,
+            scheduleDate,
+        });
+    }
+
+    async updateTournament (tournamentId: string, tournament: Partial<TournamentManyTablesRoom>): Promise<TournamentManyTablesRoomDocument> {
+        return this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    ...tournament,
+                },
+            }).exec();
+    }
+
+    async removeTournament (tournamentId: string): Promise<void> {
+        await this.tournamentModel.findByIdAndDelete(tournamentId);
+    }
+
+    async startTournament (tournamentId: string): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            {
+                $set: {
+                    startDate: new Date(),
+                    status: TournamentStatusEnum.STATE_IN_PROGRESS,
+                },
+            }).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();
+    }
+
+    async addPlayerToParticipants (tournamentId: string, player: ITournamentParticipant): Promise<void> {
+        await this.tournamentModel.findByIdAndUpdate(
+            tournamentId,
+            { $push: { participants: player } })
+            .exec();
+    }
+}

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

@@ -1,106 +1,106 @@
-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';
-import { TournamentTemplateEnum } from '../models/tournament-template.enum';
-
-@Injectable()
-export class TournamentOneTableRoomsRepository {
-    constructor (@InjectModel(TournamentOneTableRoom.name) private tournamentModel: Model<TournamentOneTableRoomDocument>) {
-    }
-
-    async findTournamentById (tournamentId: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findById(tournamentId)
-            .exec();
-    }
-
-    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findOne({ isTemplate: true, templateId, gameType })
-            .exec();
-    }
-
-    async findTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
-        return this.tournamentModel
-            .find({ gameType, isTemplate: false })
-            .exec();
-    }
-
-    async findWaitingTournament (gameType: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findOne({
-                gameType,
-                status: TournamentStatusEnum.STATE_WAITING_FOR_START,
-                isTemplate: false,
-            })
-            .exec();
-    }
-
-    async createTournament (tournament: Partial<TournamentOneTableRoom>): Promise<TournamentOneTableRoomDocument> {
-        return this.tournamentModel.create(tournament);
-    }
-
-    async createTournamentFromMasterTemplate (gameType: string): Promise<TournamentOneTableRoomDocument> {
-        const masterTemplate = await this.findTemplateById(TournamentTemplateEnum.MASTER, gameType);
-
-        return this.createTournament({
-            title: masterTemplate.title,
-            subtitle: masterTemplate.subtitle,
-            description: masterTemplate.description,
-            tableSize: masterTemplate.tableSize,
-            bet: masterTemplate.bet,
-            ticketPrice: masterTemplate.ticketPrice,
-            roomType: masterTemplate.roomType,
-            gameType: masterTemplate.gameType,
-            rulesType: masterTemplate.rulesType,
-            deckType: masterTemplate.deckType,
-            maxParticipants: masterTemplate.maxParticipants,
-            participants: masterTemplate.participants,
-            status: masterTemplate.status,
-            winners: masterTemplate.winners,
-            createDate: new Date(),
-            isTemplate: false,
-            templateId: undefined,
-        });
-    }
-
-    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();
-    }
-}
+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';
+import { TournamentTemplateEnum } from '../models/tournament-template.enum';
+
+@Injectable()
+export class TournamentOneTableRoomsRepository {
+    constructor (@InjectModel(TournamentOneTableRoom.name) private tournamentModel: Model<TournamentOneTableRoomDocument>) {
+    }
+
+    async findTournamentById (tournamentId: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findById(tournamentId)
+            .exec();
+    }
+
+    async findTemplateById (templateId: string, gameType: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({ isTemplate: true, templateId, gameType })
+            .exec();
+    }
+
+    async findTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
+        return this.tournamentModel
+            .find({ gameType, isTemplate: false })
+            .exec();
+    }
+
+    async findWaitingTournament (gameType: string): Promise<TournamentOneTableRoomDocument | null> {
+        return this.tournamentModel
+            .findOne({
+                gameType,
+                status: TournamentStatusEnum.STATE_WAITING_FOR_START,
+                isTemplate: false,
+            })
+            .exec();
+    }
+
+    async createTournament (tournament: Partial<TournamentOneTableRoom>): Promise<TournamentOneTableRoomDocument> {
+        return this.tournamentModel.create(tournament);
+    }
+
+    async createTournamentFromMasterTemplate (gameType: string): Promise<TournamentOneTableRoomDocument> {
+        const masterTemplate = await this.findTemplateById(TournamentTemplateEnum.MASTER, gameType);
+
+        return this.createTournament({
+            title: masterTemplate.title,
+            subtitle: masterTemplate.subtitle,
+            description: masterTemplate.description,
+            tableSize: masterTemplate.tableSize,
+            bet: masterTemplate.bet,
+            ticketPrice: masterTemplate.ticketPrice,
+            roomType: masterTemplate.roomType,
+            gameType: masterTemplate.gameType,
+            rulesType: masterTemplate.rulesType,
+            deckType: masterTemplate.deckType,
+            maxParticipants: masterTemplate.maxParticipants,
+            participants: masterTemplate.participants,
+            status: masterTemplate.status,
+            winners: masterTemplate.winners,
+            createDate: new Date(),
+            isTemplate: false,
+            templateId: undefined,
+        });
+    }
+
+    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();
+    }
+}