jp.db.schemas 2.2.10 → 2.2.12

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

@@ -1,171 +1,167 @@
-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 { ManyTablesTournamentRoom, ManyTablesTournamentRoomDocument } 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 ManyTablesTournamentRoomsRepository {
+  constructor(
+    @InjectModel(ManyTablesTournamentRoom.name)
+    private tournamentModel: Model<ManyTablesTournamentRoomDocument>,
+  ) {}
+
+  async findTournamentById(
+    tournamentId: string,
+  ): Promise<ManyTablesTournamentRoomDocument | null> {
+    return this.tournamentModel.findById(tournamentId).exec();
+  }
+
+  async findTemplateById(
+    templateId: string,
+    gameType: string,
+  ): Promise<ManyTablesTournamentRoomDocument | null> {
+    return this.tournamentModel.findOne({ templateId, gameType }).exec();
+  }
+
+  async findActualTournaments(
+    gameType: string,
+  ): Promise<Array<ManyTablesTournamentRoomDocument>> {
+    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<ManyTablesTournamentRoomDocument | null> {
+    return this.tournamentModel
+      .findOne({
+        gameType,
+        status: TournamentStatusEnum.STATE_WAITING_FOR_START,
+        isTemplate: false,
+        scheduleDate: { $gte: startDate, $lt: endDate },
+      })
+      .exec();
+  }
+
+  async createTournament(
+    tournament: Partial<ManyTablesTournamentRoom>,
+  ): Promise<ManyTablesTournamentRoomDocument> {
+    return this.tournamentModel.create(tournament);
+  }
+
+  async scheduleTournamentFromMasterTemplate(
+    gameType: string,
+    scheduleDate: Date,
+  ): Promise<ManyTablesTournamentRoomDocument> {
+    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<ManyTablesTournamentRoom>,
+  ): Promise<ManyTablesTournamentRoomDocument> {
+    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/menu.repository.ts

@@ -1,19 +1,19 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Menu, MenuDocument } from '../';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class MenuRepository {
-  constructor(@InjectModel(Menu.name) private menuModel: Model<MenuDocument>) {}
-
-  async findMenus(channel: string, game: string): Promise<Array<Menu> | null> {
-    return this.menuModel
-      .find({
-        channels: getChannelRegExpFilter(channel),
-      })
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Menu, MenuDocument } from '../';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class MenuRepository {
+  constructor(@InjectModel(Menu.name) private menuModel: Model<MenuDocument>) {}
+
+  async findMenus(channel: string, game: string): Promise<Array<Menu> | null> {
+    return this.menuModel
+      .find({
+        channels: getChannelRegExpFilter(channel),
+      })
+      .exec();
+  }
+}

package/src/repositories/notification.repository.ts

@@ -1,59 +1,59 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Notification, NotificationDocument } from '../';
-
-@Injectable()
-export class NotificationRepository {
-  constructor(
-    @InjectModel(Notification.name)
-    private notificationModel: Model<NotificationDocument>,
-  ) {}
-
-  async findById(id: string): Promise<Notification | null> {
-    return this.notificationModel.findById(id).exec();
-  }
-
-  async findAndCount(
-    limit: number,
-    skip: number,
-  ): Promise<{
-    items: Array<Notification>;
-    total: number;
-  }> {
-    const items = await this.notificationModel
-      .find()
-      .sort({ createDate: -1 })
-      .limit(limit)
-      .skip(skip)
-      .exec();
-
-    const total = await this.notificationModel.find().countDocuments().exec();
-
-    return { items, total };
-  }
-
-  public async crateNotification(
-    notification: Notification,
-  ): Promise<Notification> {
-    return this.notificationModel.create(notification);
-  }
-
-  async updateNotification(
-    notificationId: string,
-    notification: Partial<Notification>,
-  ): Promise<void> {
-    await this.notificationModel
-      .findByIdAndUpdate(notificationId, {
-        $set: {
-          ...notification,
-        },
-      })
-      .exec();
-  }
-
-  public async removeNotification(notificationId: string): Promise<void> {
-    await this.notificationModel.findByIdAndDelete(notificationId);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Notification, NotificationDocument } from '../';
+
+@Injectable()
+export class NotificationRepository {
+  constructor(
+    @InjectModel(Notification.name)
+    private notificationModel: Model<NotificationDocument>,
+  ) {}
+
+  async findById(id: string): Promise<Notification | null> {
+    return this.notificationModel.findById(id).exec();
+  }
+
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<Notification>;
+    total: number;
+  }> {
+    const items = await this.notificationModel
+      .find()
+      .sort({ createDate: -1 })
+      .limit(limit)
+      .skip(skip)
+      .exec();
+
+    const total = await this.notificationModel.find().countDocuments().exec();
+
+    return { items, total };
+  }
+
+  public async crateNotification(
+    notification: Notification,
+  ): Promise<Notification> {
+    return this.notificationModel.create(notification);
+  }
+
+  async updateNotification(
+    notificationId: string,
+    notification: Partial<Notification>,
+  ): Promise<void> {
+    await this.notificationModel
+      .findByIdAndUpdate(notificationId, {
+        $set: {
+          ...notification,
+        },
+      })
+      .exec();
+  }
+
+  public async removeNotification(notificationId: string): Promise<void> {
+    await this.notificationModel.findByIdAndDelete(notificationId);
+  }
+}