jp.db.schemas 2.0.26 → 2.1.0

package/src/repositories/products.repository.ts

@@ -1,29 +1,29 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Product, ProductDocument } from '../';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class ProductsRepository {
-    constructor (@InjectModel(Product.name) private productModel: Model<ProductDocument>) {
-    }
-
-    async findByProductId (productId: string): Promise<Product | null> {
-        return this.productModel
-            .findOne({ productId })
-            .exec();
-    }
-
-    async findProducts (parentId: string | null, channel: string): Promise<Array<Product> | null> {
-        return this.productModel
-            .find({
-                parentId,
-                active: true,
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
-}
-
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Product, ProductDocument } from '../';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class ProductsRepository {
+    constructor (@InjectModel(Product.name) private productModel: Model<ProductDocument>) {
+    }
+
+    async findByProductId (productId: string): Promise<Product | null> {
+        return this.productModel
+            .findOne({ productId })
+            .exec();
+    }
+
+    async findProducts (parentId: string | null, channel: string): Promise<Array<Product> | null> {
+        return this.productModel
+            .find({
+                parentId,
+                active: true,
+                channels: getChannelRegExpFilter(channel),
+            })
+            .exec();
+    }
+}
+

package/src/repositories/rooms.repository.ts

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

package/src/repositories/rule.repository.ts

@@ -1,20 +1,20 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Rule, RuleDocument } from '..';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class RuleRepository {
-    constructor (@InjectModel(Rule.name) private ruleModel: Model<RuleDocument>) {
-    }
-
-    async findRule (channel: string, game: string): Promise<Array<Rule> | null> {
-        return this.ruleModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Rule, RuleDocument } from '..';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class RuleRepository {
+    constructor (@InjectModel(Rule.name) private ruleModel: Model<RuleDocument>) {
+    }
+
+    async findRule (channel: string, game: string): Promise<Array<Rule> | null> {
+        return this.ruleModel
+            .find({
+                channels: getChannelRegExpFilter(channel),
+            })
+            .exec();
+    }
 }

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

@@ -1,30 +1,30 @@
-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,18 +1,18 @@
-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,20 +1,20 @@
-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 findSetting (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 findSetting (channel: string, game: string): Promise<Array<Setting> | null> {
+        return this.settingModel
+            .find({
+                channels: getChannelRegExpFilter(channel),
+            })
+            .exec();
+    }
 }

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

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