jp.db.schemas 2.2.10 → 2.2.12

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

@@ -1,142 +1,142 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import dayjs from 'dayjs';
-
-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 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 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 dayjs from 'dayjs';
+
+import { OneTableTournamentRoom, OneTableTournamentRoomDocument } 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 OneTableTournamentRoomsRepository {
+  constructor(
+    @InjectModel(OneTableTournamentRoom.name)
+    private tournamentModel: Model<OneTableTournamentRoomDocument>,
+  ) {}
+
+  async findTournamentById(
+    tournamentId: string,
+  ): Promise<OneTableTournamentRoomDocument | null> {
+    return this.tournamentModel.findById(tournamentId).exec();
+  }
+
+  async findTemplateById(
+    templateId: string,
+    gameType: string,
+  ): Promise<OneTableTournamentRoomDocument | null> {
+    return this.tournamentModel
+      .findOne({ isTemplate: true, templateId, gameType })
+      .exec();
+  }
+
+  async findActualTournaments(
+    gameType: string,
+  ): Promise<Array<OneTableTournamentRoomDocument>> {
+    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<OneTableTournamentRoomDocument | null> {
+    return this.tournamentModel
+      .findOne({
+        gameType,
+        status: TournamentStatusEnum.STATE_WAITING_FOR_START,
+        isTemplate: false,
+      })
+      .exec();
+  }
+
+  async createTournament(
+    tournament: Partial<OneTableTournamentRoom>,
+  ): Promise<OneTableTournamentRoomDocument> {
+    return this.tournamentModel.create(tournament);
+  }
+
+  async createTournamentFromMasterTemplate(
+    gameType: string,
+  ): Promise<OneTableTournamentRoomDocument> {
+    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();
+  }
+}

package/src/repositories/premium.repository.ts

@@ -1,16 +1,16 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Premium, PremiumDocument } from '..';
-
-@Injectable()
-export class PremiumRepository {
-  constructor(
-    @InjectModel(Premium.name) private premiumModel: Model<PremiumDocument>,
-  ) {}
-
-  async findPremium(gameType: string): Promise<Premium | null> {
-    return this.premiumModel.findOne({ gameType }).exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Premium, PremiumDocument } from '..';
+
+@Injectable()
+export class PremiumRepository {
+  constructor(
+    @InjectModel(Premium.name) private premiumModel: Model<PremiumDocument>,
+  ) {}
+
+  async findPremium(gameType: string): Promise<Premium | null> {
+    return this.premiumModel.findOne({ gameType }).exec();
+  }
+}

package/src/repositories/products.repository.ts

@@ -1,30 +1,30 @@
-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/purchase.repository.ts

@@ -1,111 +1,111 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Purchase, PurchaseDocument } from '..';
-import { CurrencyEnum } from '../models/currency.enum';
-
-@Injectable()
-export class PurchaseRepository {
-  constructor(
-    @InjectModel(Purchase.name) private purchaseModel: Model<PurchaseDocument>,
-  ) {}
-
-  async findPurchasesByUserId(userId: string): Promise<Array<Purchase>> {
-    return this.purchaseModel.find({ userId }).exec();
-  }
-
-  async findPurchaseByVKOrderId(vkOrderId: number): Promise<Purchase | null> {
-    return this.purchaseModel.findOne({ vkOrderId }).exec();
-  }
-
-  async findPurchaseByYaOrderId(yaOrderId: string): Promise<Purchase | null> {
-    return this.purchaseModel.findOne({ yaOrderId }).exec();
-  }
-
-  async addVKPurchase(
-    userId: string,
-    userName: string,
-    productId: string,
-    productCode: string,
-    productName: string,
-    price: number,
-    vkOrderId: number,
-    token: string,
-    game: string,
-  ): Promise<Purchase> {
-    return this.addPurchase({
-      userId,
-      userName,
-      productId,
-      productCode,
-      productName,
-      price,
-      currency: CurrencyEnum.VK_VOTES,
-      vkOrderId,
-      token,
-      game,
-    });
-  }
-
-  async addYAPUrchase(
-    userId: string,
-    userName: string,
-    productId: string,
-    productCode: string,
-    productName: string,
-    price: number,
-    yaOrderId: string,
-    token: string,
-    game: string,
-  ): Promise<Purchase> {
-    return this.addPurchase({
-      userId,
-      userName,
-      productId,
-      productCode,
-      productName,
-      price,
-      currency: CurrencyEnum.YAN,
-      yaOrderId,
-      token,
-      game,
-    });
-  }
-
-  async addManyTablesTournamentTicketPurchase(
-    userId: string,
-    userName: string,
-    tournamentId: string,
-    price: number,
-    game: string,
-  ): Promise<Purchase> {
-    return this.addPurchase({
-      userId,
-      userName,
-      productId: '6a192b118e596305dc9d0484',
-      productCode: 'tournament_ticket__evening',
-      productName: 'Ticket on evenint tournament',
-      tournamentId,
-      price,
-      currency: CurrencyEnum.JP,
-      game,
-    });
-  }
-
-  async addPurchase(purchase: Partial<Purchase>): Promise<Purchase> {
-    return this.purchaseModel.create(purchase);
-  }
-
-  async removeByVKOkderId(vkOrderId: number): Promise<Purchase | null> {
-    return this.purchaseModel
-      .findOneAndUpdate(
-        { vkOrderId },
-        {
-          removed: true,
-        },
-        { new: true },
-      )
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Purchase, PurchaseDocument } from '..';
+import { CurrencyEnum } from '../models/currency.enum';
+
+@Injectable()
+export class PurchaseRepository {
+  constructor(
+    @InjectModel(Purchase.name) private purchaseModel: Model<PurchaseDocument>,
+  ) {}
+
+  async findPurchasesByUserId(userId: string): Promise<Array<Purchase>> {
+    return this.purchaseModel.find({ userId }).exec();
+  }
+
+  async findPurchaseByVKOrderId(vkOrderId: number): Promise<Purchase | null> {
+    return this.purchaseModel.findOne({ vkOrderId }).exec();
+  }
+
+  async findPurchaseByYaOrderId(yaOrderId: string): Promise<Purchase | null> {
+    return this.purchaseModel.findOne({ yaOrderId }).exec();
+  }
+
+  async addVKPurchase(
+    userId: string,
+    userName: string,
+    productId: string,
+    productCode: string,
+    productName: string,
+    price: number,
+    vkOrderId: number,
+    token: string,
+    game: string,
+  ): Promise<Purchase> {
+    return this.addPurchase({
+      userId,
+      userName,
+      productId,
+      productCode,
+      productName,
+      price,
+      currency: CurrencyEnum.VK_VOTES,
+      vkOrderId,
+      token,
+      game,
+    });
+  }
+
+  async addYAPUrchase(
+    userId: string,
+    userName: string,
+    productId: string,
+    productCode: string,
+    productName: string,
+    price: number,
+    yaOrderId: string,
+    token: string,
+    game: string,
+  ): Promise<Purchase> {
+    return this.addPurchase({
+      userId,
+      userName,
+      productId,
+      productCode,
+      productName,
+      price,
+      currency: CurrencyEnum.YAN,
+      yaOrderId,
+      token,
+      game,
+    });
+  }
+
+  async addManyTablesTournamentTicketPurchase(
+    userId: string,
+    userName: string,
+    tournamentId: string,
+    price: number,
+    game: string,
+  ): Promise<Purchase> {
+    return this.addPurchase({
+      userId,
+      userName,
+      productId: '6a192b118e596305dc9d0484',
+      productCode: 'tournament_ticket__evening',
+      productName: 'Ticket on evenint tournament',
+      tournamentId,
+      price,
+      currency: CurrencyEnum.JP,
+      game,
+    });
+  }
+
+  async addPurchase(purchase: Partial<Purchase>): Promise<Purchase> {
+    return this.purchaseModel.create(purchase);
+  }
+
+  async removeByVKOkderId(vkOrderId: number): Promise<Purchase | null> {
+    return this.purchaseModel
+      .findOneAndUpdate(
+        { vkOrderId },
+        {
+          removed: true,
+        },
+        { new: true },
+      )
+      .exec();
+  }
+}