jp.db.schemas 2.2.10 → 2.2.11

package/src/repositories/scheduled-tournaments.repository.ts

@@ -1,35 +1,35 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { ScheduledTournament, ScheduledTournamentDocument } from '../';
-
-@Injectable()
-export class ScheduledTournamentsRepository {
-  constructor(
-    @InjectModel(ScheduledTournament.name)
-    private scheduledTournamentModel: Model<ScheduledTournamentDocument>,
-  ) {}
-
-  async findAndCount(
-    limit: number,
-    skip: number,
-  ): Promise<{
-    items: Array<ScheduledTournament>;
-    total: number;
-  }> {
-    const items = await this.scheduledTournamentModel
-      .find({ category: 'global' })
-      .sort({ date: -1 })
-      .limit(limit)
-      .skip(skip)
-      .exec();
-
-    const total = await this.scheduledTournamentModel
-      .find({ category: 'global' })
-      .countDocuments()
-      .exec();
-
-    return { items, total };
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { ScheduledTournament, ScheduledTournamentDocument } from '../';
+
+@Injectable()
+export class ScheduledTournamentsRepository {
+  constructor(
+    @InjectModel(ScheduledTournament.name)
+    private scheduledTournamentModel: Model<ScheduledTournamentDocument>,
+  ) {}
+
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<ScheduledTournament>;
+    total: number;
+  }> {
+    const items = await this.scheduledTournamentModel
+      .find({ category: 'global' })
+      .sort({ date: -1 })
+      .limit(limit)
+      .skip(skip)
+      .exec();
+
+    const total = await this.scheduledTournamentModel
+      .find({ category: 'global' })
+      .countDocuments()
+      .exec();
+
+    return { items, total };
+  }
+}

package/src/repositories/servers.repository.ts

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

package/src/repositories/setting.repository.ts

@@ -1,24 +1,24 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Setting, SettingDocument } from '..';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class SettingRepository {
-  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();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Setting, SettingDocument } from '..';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class SettingRepository {
+  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();
+  }
+}

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

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

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

@@ -1,16 +1,16 @@
-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();
-  }
-}
+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

@@ -1,171 +1,171 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import dayjs from 'dayjs';
-
-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 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 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 dayjs from 'dayjs';
+
+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 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 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();
+  }
+}