jp.db.schemas 2.2.9 → 2.2.10

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

@@ -1,120 +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,43 +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,28 +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);
+  }
+}