jp.db.schemas 2.2.9 → 2.2.11

package/src/repositories/index.ts

@@ -29,33 +29,33 @@ import { UsersBalancesRepository } from './users-balances.repository';
 import { UsersAchievementsRepository } from './users-achievements.repository';
 
 export {
-    AdminRepository,
-    ArticleRepository,
-    BannersRepository,
-    ComplainsRepository,
-    NotificationRepository,
-    ProductsRepository,
-    ScheduledTournamentsRepository,
-    ServersRepository,
-    UsersRepository,
-    MenuRepository,
-    RatingRepository,
-    GameStatisticRepository,
-    RuleRepository,
-    FriendRepository,
-    SettingRepository,
-    PremiumRepository,
-    WelcomeRepository,
-    DailyBonusRepository,
-    RoomsRepository,
-    GameResultRepository,
-    SimpleRoomsRepository,
-    TournamentOneTableRoomsRepository,
-    TournamentManyTablesRoomsRepository,
-    ActivityLogRepository,
-    AchievementRepository,
-    PurchaseRepository,
-    SettingsOptionsRepository,
-    UsersBalancesRepository,
-    UsersAchievementsRepository
-}
+  AdminRepository,
+  ArticleRepository,
+  BannersRepository,
+  ComplainsRepository,
+  NotificationRepository,
+  ProductsRepository,
+  ScheduledTournamentsRepository,
+  ServersRepository,
+  UsersRepository,
+  MenuRepository,
+  RatingRepository,
+  GameStatisticRepository,
+  RuleRepository,
+  FriendRepository,
+  SettingRepository,
+  PremiumRepository,
+  WelcomeRepository,
+  DailyBonusRepository,
+  RoomsRepository,
+  GameResultRepository,
+  SimpleRoomsRepository,
+  TournamentOneTableRoomsRepository,
+  TournamentManyTablesRoomsRepository,
+  ActivityLogRepository,
+  AchievementRepository,
+  PurchaseRepository,
+  SettingsOptionsRepository,
+  UsersBalancesRepository,
+  UsersAchievementsRepository,
+};

package/src/repositories/menu.repository.ts

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

package/src/repositories/notification.repository.ts

@@ -6,18 +6,21 @@ import { Notification, NotificationDocument } from '../';
 
 @Injectable()
 export class NotificationRepository {
-  constructor (@InjectModel(Notification.name) private notificationModel: Model<NotificationDocument>) {
-  }
+  constructor(
+    @InjectModel(Notification.name)
+    private notificationModel: Model<NotificationDocument>,
+  ) {}
 
-  async findById (id: string): Promise<Notification | null> {
-    return this.notificationModel
-      .findById(id)
-      .exec();
+  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
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<Notification>;
+    total: number;
   }> {
     const items = await this.notificationModel
       .find()
@@ -26,29 +29,31 @@ export class NotificationRepository {
       .skip(skip)
       .exec();
 
-    const total = await this.notificationModel
-      .find()
-      .countDocuments()
-      .exec();
+    const total = await this.notificationModel.find().countDocuments().exec();
 
     return { items, total };
   }
 
-  public async crateNotification (notification: Notification): Promise<Notification> {
+  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,
-      {
+  async updateNotification(
+    notificationId: string,
+    notification: Partial<Notification>,
+  ): Promise<void> {
+    await this.notificationModel
+      .findByIdAndUpdate(notificationId, {
         $set: {
           ...notification,
         },
-      }).exec();
+      })
+      .exec();
   }
 
-  public async removeNotification (notificationId: string): Promise<void> {
+  public async removeNotification(notificationId: string): Promise<void> {
     await this.notificationModel.findByIdAndDelete(notificationId);
   }
 }

package/src/repositories/premium.repository.ts

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

package/src/repositories/products.repository.ts

@@ -7,23 +7,24 @@ import { getChannelRegExpFilter } from '../utils';
 
 @Injectable()
 export class ProductsRepository {
-    constructor (@InjectModel(Product.name) private productModel: Model<ProductDocument>) {
-    }
+  constructor(
+    @InjectModel(Product.name) private productModel: Model<ProductDocument>,
+  ) {}
 
-    async findByProductId (productId: string): Promise<Product | null> {
-        return this.productModel
-            .findOne({ productId })
-            .exec();
-    }
+  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();
-    }
+  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

@@ -7,109 +7,105 @@ import { CurrencyEnum } from '../models/currency.enum';
 
 @Injectable()
 export class PurchaseRepository {
-    constructor(@InjectModel(Purchase.name) private purchaseModel: Model<PurchaseDocument>) {
-    }
+  constructor(
+    @InjectModel(Purchase.name) private purchaseModel: Model<PurchaseDocument>,
+  ) {}
 
-    async findPurchasesByUserId (userId: string): Promise<Array<Purchase>> {
-        return this.purchaseModel
-            .find({ userId })
-            .exec();
-    }
+  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 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 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 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 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 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 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();
-    }
+  async removeByVKOkderId(vkOrderId: number): Promise<Purchase | null> {
+    return this.purchaseModel
+      .findOneAndUpdate(
+        { vkOrderId },
+        {
+          removed: true,
+        },
+        { new: true },
+      )
+      .exec();
+  }
 }
-

package/src/repositories/rating.repository.ts

@@ -8,77 +8,83 @@ import { IRatingMonthlyResult } from '../models/rating-monthly-result.interface'
 
 @Injectable()
 export class RatingRepository {
-    constructor(@InjectModel(Rating.name) private ratingModel: Model<RatingDocument>) {
-    }
+  constructor(
+    @InjectModel(Rating.name) private ratingModel: Model<RatingDocument>,
+  ) {}
 
-    async findRating(channel: string, game: string): Promise<Array<Rating> | null> {
-        return this.ratingModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
+  async findRating(
+    channel: string,
+    game: string,
+  ): Promise<Array<Rating> | null> {
+    return this.ratingModel
+      .find({
+        channels: getChannelRegExpFilter(channel),
+      })
+      .exec();
+  }
 
-            })
-            .exec();
-    }
+  async addBulkPlayerRating(items: Array<Rating>): Promise<void> {
+    await this.ratingModel.insertMany(items);
+  }
 
-    async addBulkPlayerRating(items: Array<Rating>): Promise<void> {
-        this.ratingModel.insertMany(items);
-    }
-
-    async getMonthlyRatingList(game: string, startDate: Date, endDate: Date): Promise<Array<IRatingMonthlyResult>> {
-        return this.ratingModel.aggregate([
-            {
-                $match: {
-                    game,
-                    date: {
-                        $gte: startDate,
-                        $lte: endDate,
-                    },
-                }
-            },
-            {
-                $group:
-                {
-                    _id: {
-                        userId: "$userId",
-                        date: {
-                            $dateToString: {
-                                format: "%Y-%m",
-                                date: "$date"
-                            }
-                        }
-                    },
-                    userId: { $first: "$userId" },
-                    userName: { $first: "$userName" },
-                    userAvatarUrl: { $first: "$userAvatarUrl" },
-                    game: { $first: "$game" },
-                    channels: { $first: "$channels" },
-                    count: { $sum: 1 },
-                    profit: { $sum: "$profit" }
-                }
-            },
-            {
-                $sort: { profit: -1 }
-            },
-            {
-                $setWindowFields: {
-                    sortBy: { profit: -1 },
-                    output: { rank: { $rank: {} } }
-                }
+  async getMonthlyRatingList(
+    game: string,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<Array<IRatingMonthlyResult>> {
+    return this.ratingModel.aggregate([
+      {
+        $match: {
+          game,
+          date: {
+            $gte: startDate,
+            $lte: endDate,
+          },
+        },
+      },
+      {
+        $group: {
+          _id: {
+            userId: '$userId',
+            date: {
+              $dateToString: {
+                format: '%Y-%m',
+                date: '$date',
+              },
             },
-            {
-                $project: {
-                    _id: 0,
-                    id: { $concat: ["$_id.userId", "_", "$_id.date"] },
-                    userId: 1,
-                    userName: 1,
-                    userAvatarUrl: 1,
-                    game: 1,
-                    channels: 1,
-                    count: 1,
-                    date: "$_id.date",
-                    rank: 1,
-                }
-            }
-        ]);
-    }
-}
+          },
+          userId: { $first: '$userId' },
+          userName: { $first: '$userName' },
+          userAvatarUrl: { $first: '$userAvatarUrl' },
+          game: { $first: '$game' },
+          channels: { $first: '$channels' },
+          count: { $sum: 1 },
+          profit: { $sum: '$profit' },
+        },
+      },
+      {
+        $sort: { profit: -1 },
+      },
+      {
+        $setWindowFields: {
+          sortBy: { profit: -1 },
+          output: { rank: { $rank: {} } },
+        },
+      },
+      {
+        $project: {
+          _id: 0,
+          id: { $concat: ['$_id.userId', '_', '$_id.date'] },
+          userId: 1,
+          userName: 1,
+          userAvatarUrl: 1,
+          game: 1,
+          channels: 1,
+          count: 1,
+          date: '$_id.date',
+          rank: 1,
+        },
+      },
+    ]);
+  }
+}

package/src/repositories/rooms.repository.ts

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

package/src/repositories/rule.repository.ts

@@ -3,16 +3,12 @@ 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>) {
-    }
+  constructor(@InjectModel(Rule.name) private ruleModel: Model<RuleDocument>) {}
 
-    async findRule ( gameType: string ): Promise<Rule | null> {
-        return this.ruleModel
-            .findOne({ gameType })
-            .exec();
-    }
-}
+  async findRule(gameType: string): Promise<Rule | null> {
+    return this.ruleModel.findOne({ gameType }).exec();
+  }
+}

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

@@ -6,22 +6,27 @@ import { ScheduledTournament, ScheduledTournamentDocument } from '../';
 
 @Injectable()
 export class ScheduledTournamentsRepository {
-  constructor (@InjectModel(ScheduledTournament.name) private scheduledTournamentModel: Model<ScheduledTournamentDocument>) {
-  }
+  constructor(
+    @InjectModel(ScheduledTournament.name)
+    private scheduledTournamentModel: Model<ScheduledTournamentDocument>,
+  ) {}
 
-  async findAndCount (limit: number, skip: number): Promise<{
-    items: Array<ScheduledTournament>,
-    total: number
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<ScheduledTournament>;
+    total: number;
   }> {
     const items = await this.scheduledTournamentModel
-      .find({ category: 'global'})
+      .find({ category: 'global' })
       .sort({ date: -1 })
       .limit(limit)
       .skip(skip)
       .exec();
 
     const total = await this.scheduledTournamentModel
-      .find({ category: 'global'})
+      .find({ category: 'global' })
       .countDocuments()
       .exec();