jp.db.schemas 2.2.10 → 2.2.11

package/src/repositories/tournament-one-table-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 { 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();
+  }
+}

package/src/repositories/users-achievements.repository.ts

@@ -1,46 +1,46 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { UsersAchievement, UsersAchievementDocument } from '..';
-
-@Injectable()
-export class UsersAchievementsRepository {
-  constructor(
-    @InjectModel(UsersAchievement.name)
-    private usersAchievementModel: Model<UsersAchievementDocument>,
-  ) {}
-
-  async findAchivementsByUserId(
-    userId: string,
-  ): Promise<Array<UsersAchievement>> {
-    return this.usersAchievementModel.find({ userId }).exec();
-  }
-
-  async findAchivementsByUserIdAndAchievementCode(
-    userId: string,
-    achievementCode: string,
-  ): Promise<Array<UsersAchievement>> {
-    return this.usersAchievementModel.find({ userId, achievementCode }).exec();
-  }
-
-  async addUsersAchievement(
-    userId: string,
-    userName: string,
-    achievementId: string,
-    achievementTitle: string,
-    achievementCode: string,
-    achievementPrize: number,
-    game: string,
-  ): Promise<UsersAchievement> {
-    return this.usersAchievementModel.create({
-      userId,
-      userName,
-      achievementId,
-      achievementTitle,
-      achievementCode,
-      achievementPrize,
-      game,
-    });
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { UsersAchievement, UsersAchievementDocument } from '..';
+
+@Injectable()
+export class UsersAchievementsRepository {
+  constructor(
+    @InjectModel(UsersAchievement.name)
+    private usersAchievementModel: Model<UsersAchievementDocument>,
+  ) {}
+
+  async findAchivementsByUserId(
+    userId: string,
+  ): Promise<Array<UsersAchievement>> {
+    return this.usersAchievementModel.find({ userId }).exec();
+  }
+
+  async findAchivementsByUserIdAndAchievementCode(
+    userId: string,
+    achievementCode: string,
+  ): Promise<Array<UsersAchievement>> {
+    return this.usersAchievementModel.find({ userId, achievementCode }).exec();
+  }
+
+  async addUsersAchievement(
+    userId: string,
+    userName: string,
+    achievementId: string,
+    achievementTitle: string,
+    achievementCode: string,
+    achievementPrize: number,
+    game: string,
+  ): Promise<UsersAchievement> {
+    return this.usersAchievementModel.create({
+      userId,
+      userName,
+      achievementId,
+      achievementTitle,
+      achievementCode,
+      achievementPrize,
+      game,
+    });
+  }
+}

package/src/repositories/users-balances.repository.ts

@@ -1,65 +1,65 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { UsersBalance, UsersBalanceDocument } from '..';
-import { UsersBalanceReasonEnum } from '../models/users-balance-reason.enum';
-
-@Injectable()
-export class UsersBalancesRepository {
-  constructor(
-    @InjectModel(UsersBalance.name)
-    private usersBalanceModel: Model<UsersBalanceDocument>,
-  ) {}
-
-  async addUsersBalanceByRegister(
-    userId: string,
-    userName: string,
-    amount: number,
-    game: string,
-  ): Promise<UsersBalance> {
-    return this.createUsersBalance({
-      userId,
-      userName,
-      amount,
-      reason: UsersBalanceReasonEnum.REGISTER,
-      game,
-    });
-  }
-
-  async addUsersBalanceByDailyBonus(
-    userId: string,
-    userName: string,
-    amount: number,
-    game: string,
-  ): Promise<UsersBalance> {
-    return this.createUsersBalance({
-      userId,
-      userName,
-      amount,
-      reason: UsersBalanceReasonEnum.DAILY_BONUS,
-      game,
-    });
-  }
-
-  async addUsersBalanceByShopPurchase(
-    userId: string,
-    userName: string,
-    amount: number,
-    game: string,
-  ): Promise<UsersBalance> {
-    return this.createUsersBalance({
-      userId,
-      userName,
-      amount,
-      reason: UsersBalanceReasonEnum.SHOP_PURCHASE,
-      game,
-    });
-  }
-
-  async createUsersBalance(
-    usersBalance: Partial<UsersBalance>,
-  ): Promise<UsersBalance> {
-    return this.usersBalanceModel.create(usersBalance);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { UsersBalance, UsersBalanceDocument } from '..';
+import { UsersBalanceReasonEnum } from '../models/users-balance-reason.enum';
+
+@Injectable()
+export class UsersBalancesRepository {
+  constructor(
+    @InjectModel(UsersBalance.name)
+    private usersBalanceModel: Model<UsersBalanceDocument>,
+  ) {}
+
+  async addUsersBalanceByRegister(
+    userId: string,
+    userName: string,
+    amount: number,
+    game: string,
+  ): Promise<UsersBalance> {
+    return this.createUsersBalance({
+      userId,
+      userName,
+      amount,
+      reason: UsersBalanceReasonEnum.REGISTER,
+      game,
+    });
+  }
+
+  async addUsersBalanceByDailyBonus(
+    userId: string,
+    userName: string,
+    amount: number,
+    game: string,
+  ): Promise<UsersBalance> {
+    return this.createUsersBalance({
+      userId,
+      userName,
+      amount,
+      reason: UsersBalanceReasonEnum.DAILY_BONUS,
+      game,
+    });
+  }
+
+  async addUsersBalanceByShopPurchase(
+    userId: string,
+    userName: string,
+    amount: number,
+    game: string,
+  ): Promise<UsersBalance> {
+    return this.createUsersBalance({
+      userId,
+      userName,
+      amount,
+      reason: UsersBalanceReasonEnum.SHOP_PURCHASE,
+      game,
+    });
+  }
+
+  async createUsersBalance(
+    usersBalance: Partial<UsersBalance>,
+  ): Promise<UsersBalance> {
+    return this.usersBalanceModel.create(usersBalance);
+  }
+}