jp.db.schemas 2.2.9 → 2.2.11

package/src/repositories/servers.repository.ts

@@ -6,13 +6,11 @@ import { Server, ServerDocument } from '../';
 
 @Injectable()
 export class ServersRepository {
-    constructor (@InjectModel(Server.name) private serverModel: Model<ServerDocument>) {
-    }
+  constructor(
+    @InjectModel(Server.name) private serverModel: Model<ServerDocument>,
+  ) {}
 
-    async findServerByName (name: string): Promise<Server | null> {
-        return this.serverModel
-            .findOne({name})
-            .exec();
-    }
+  async findServerByName(name: string): Promise<Server | null> {
+    return this.serverModel.findOne({ name }).exec();
+  }
 }
-

package/src/repositories/setting.repository.ts

@@ -7,14 +7,18 @@ import { getChannelRegExpFilter } from '../utils';
 
 @Injectable()
 export class SettingRepository {
-    constructor (@InjectModel(Setting.name) private settingModel: Model<SettingDocument>) {
-    }
+  constructor(
+    @InjectModel(Setting.name) private settingModel: Model<SettingDocument>,
+  ) {}
 
-    async findSettings (channel: string, game: string): Promise<Array<Setting> | null> {
-        return this.settingModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
-}
+  async findSettings(
+    channel: string,
+    game: string,
+  ): Promise<Array<Setting> | null> {
+    return this.settingModel
+      .find({
+        channels: getChannelRegExpFilter(channel),
+      })
+      .exec();
+  }
+}

package/src/repositories/settings-options.repository.ts

@@ -3,16 +3,15 @@ import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
 
 import { SettingsOption, SettingsOptionDocument } from '..';
-import { getChannelRegExpFilter } from '../utils';
 
 @Injectable()
 export class SettingsOptionsRepository {
-    constructor (@InjectModel(SettingsOption.name) private settingOptionsModel: Model<SettingsOptionDocument>) {
-    }
+  constructor(
+    @InjectModel(SettingsOption.name)
+    private settingOptionsModel: Model<SettingsOptionDocument>,
+  ) {}
 
-    async findSettingsOptions (): Promise<Array<SettingsOption> | null> {
-        return this.settingOptionsModel
-            .find()
-            .exec();
-    }
-}
+  async findSettingsOptions(): Promise<Array<SettingsOption> | null> {
+    return this.settingOptionsModel.find().exec();
+  }
+}

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

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

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

@@ -4,9 +4,9 @@ import { Model } from 'mongoose';
 import dayjs from 'dayjs';
 
 import {
-    TournamentManyTablesRoom,
-    TournamentManyTablesRoomDocument,
-    TournamentOneTableRoomDocument,
+  TournamentManyTablesRoom,
+  TournamentManyTablesRoomDocument,
+  TournamentOneTableRoomDocument,
 } from '../';
 import { TournamentStatusEnum } from '../models/tournament-status.enum';
 import { ITournamentWinner } from '../models/tournament-winner.interface';
@@ -15,132 +15,157 @@ import { ITournamentParticipant } from '../models/tournament-participant.interfa
 
 @Injectable()
 export class TournamentManyTablesRoomsRepository {
-    constructor(@InjectModel(TournamentManyTablesRoom.name) private tournamentModel: Model<TournamentManyTablesRoomDocument>) {
-    }
+  constructor(
+    @InjectModel(TournamentManyTablesRoom.name)
+    private tournamentModel: Model<TournamentManyTablesRoomDocument>,
+  ) {}
 
-    async findTournamentById (tournamentId: string): Promise<TournamentManyTablesRoomDocument | null> {
-        return this.tournamentModel
-            .findById(tournamentId)
-            .exec();
-    }
+  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 findTemplateById(
+    templateId: string,
+    gameType: string,
+  ): Promise<TournamentOneTableRoomDocument | null> {
+    return this.tournamentModel.findOne({ templateId, gameType }).exec();
+  }
 
-    async findActualTournaments (gameType: string): Promise<Array<TournamentManyTablesRoomDocument>> {
-        return this.tournamentModel
-            .find({
-                $and: [
-                    {
-                        isTemplate: false,
-                        gameType,
-                    },
-                    {
-                        $or: [
-                            { status: TournamentStatusEnum.STATE_WAITING_FOR_START },
-                            { finishDate: { $gte: dayjs().subtract(1, 'day').toDate() } },
-                        ]
-                    }
-                ]
-            })
-            .exec();
-    }
+  async findActualTournaments(
+    gameType: string,
+  ): Promise<Array<TournamentManyTablesRoomDocument>> {
+    return this.tournamentModel
+      .find({
+        $and: [
+          {
+            isTemplate: false,
+            gameType,
+          },
+          {
+            $or: [
+              { status: TournamentStatusEnum.STATE_WAITING_FOR_START },
+              { finishDate: { $gte: dayjs().subtract(1, 'day').toDate() } },
+            ],
+          },
+        ],
+      })
+      .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 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 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);
+  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,
-        });
-    }
+    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 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 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 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 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 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();
-    }
+  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

@@ -11,110 +11,132 @@ import { TournamentTemplateEnum } from '../models/tournament-template.enum';
 
 @Injectable()
 export class TournamentOneTableRoomsRepository {
-    constructor(@InjectModel(TournamentOneTableRoom.name) private tournamentModel: Model<TournamentOneTableRoomDocument>) {
-    }
+  constructor(
+    @InjectModel(TournamentOneTableRoom.name)
+    private tournamentModel: Model<TournamentOneTableRoomDocument>,
+  ) {}
 
-    async findTournamentById (tournamentId: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findById(tournamentId)
-            .exec();
-    }
+  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 findTemplateById(
+    templateId: string,
+    gameType: string,
+  ): Promise<TournamentOneTableRoomDocument | null> {
+    return this.tournamentModel
+      .findOne({ isTemplate: true, templateId, gameType })
+      .exec();
+  }
 
-    async findActualTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
-        return this.tournamentModel
-            .find({
-                $and: [
-                    {
-                        isTemplate: false,
-                        gameType,
-                    },
-                    {
-                        $or: [
-                            { status: TournamentStatusEnum.STATE_WAITING_FOR_START },
-                            { finishDate: { $gte: dayjs().subtract(1, 'hour').toDate() } },
-                        ]
-                    }
-                ]
-            })
-            .exec();
-    }
+  async findActualTournaments(
+    gameType: string,
+  ): Promise<Array<TournamentOneTableRoomDocument>> {
+    return this.tournamentModel
+      .find({
+        $and: [
+          {
+            isTemplate: false,
+            gameType,
+          },
+          {
+            $or: [
+              { status: TournamentStatusEnum.STATE_WAITING_FOR_START },
+              { finishDate: { $gte: dayjs().subtract(1, 'hour').toDate() } },
+            ],
+          },
+        ],
+      })
+      .exec();
+  }
 
-    async findWaitingTournament (gameType: string): Promise<TournamentOneTableRoomDocument | null> {
-        return this.tournamentModel
-            .findOne({
-                gameType,
-                status: TournamentStatusEnum.STATE_WAITING_FOR_START,
-                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 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);
+  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,
-        });
-    }
+    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 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 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 finishTournament(
+    tournamentId: string,
+    winners: Array<ITournamentWinner>,
+  ): Promise<void> {
+    await this.tournamentModel
+      .findByIdAndUpdate(tournamentId, {
+        $set: {
+          finishDate: new Date(),
+          status: TournamentStatusEnum.STATE_FINISHED,
+          winners,
+        },
+      })
+      .exec();
+  }
 }