jp.db.schemas 2.2.10 → 2.2.11

package/src/repositories/notification.repository.ts

@@ -1,59 +1,59 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Notification, NotificationDocument } from '../';
-
-@Injectable()
-export class NotificationRepository {
-  constructor(
-    @InjectModel(Notification.name)
-    private notificationModel: Model<NotificationDocument>,
-  ) {}
-
-  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;
-  }> {
-    const items = await this.notificationModel
-      .find()
-      .sort({ createDate: -1 })
-      .limit(limit)
-      .skip(skip)
-      .exec();
-
-    const total = await this.notificationModel.find().countDocuments().exec();
-
-    return { items, total };
-  }
-
-  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, {
-        $set: {
-          ...notification,
-        },
-      })
-      .exec();
-  }
-
-  public async removeNotification(notificationId: string): Promise<void> {
-    await this.notificationModel.findByIdAndDelete(notificationId);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Notification, NotificationDocument } from '../';
+
+@Injectable()
+export class NotificationRepository {
+  constructor(
+    @InjectModel(Notification.name)
+    private notificationModel: Model<NotificationDocument>,
+  ) {}
+
+  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;
+  }> {
+    const items = await this.notificationModel
+      .find()
+      .sort({ createDate: -1 })
+      .limit(limit)
+      .skip(skip)
+      .exec();
+
+    const total = await this.notificationModel.find().countDocuments().exec();
+
+    return { items, total };
+  }
+
+  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, {
+        $set: {
+          ...notification,
+        },
+      })
+      .exec();
+  }
+
+  public async removeNotification(notificationId: string): Promise<void> {
+    await this.notificationModel.findByIdAndDelete(notificationId);
+  }
+}

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();
+  }
+}

package/src/repositories/rating.repository.ts

@@ -1,90 +1,90 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Rating, RatingDocument } from '..';
-import { getChannelRegExpFilter } from '../utils';
-import { IRatingMonthlyResult } from '../models/rating-monthly-result.interface';
-
-@Injectable()
-export class RatingRepository {
-  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),
-      })
-      .exec();
-  }
-
-  async addBulkPlayerRating(items: Array<Rating>): Promise<void> {
-    await 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: {} } },
-        },
-      },
-      {
-        $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,
-        },
-      },
-    ]);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Rating, RatingDocument } from '..';
+import { getChannelRegExpFilter } from '../utils';
+import { IRatingMonthlyResult } from '../models/rating-monthly-result.interface';
+
+@Injectable()
+export class RatingRepository {
+  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),
+      })
+      .exec();
+  }
+
+  async addBulkPlayerRating(items: Array<Rating>): Promise<void> {
+    await 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: {} } },
+        },
+      },
+      {
+        $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

@@ -1,14 +1,14 @@
-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,14 +1,14 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Rule, RuleDocument } from '..';
-
-@Injectable()
-export class RuleRepository {
-  constructor(@InjectModel(Rule.name) private ruleModel: Model<RuleDocument>) {}
-
-  async findRule(gameType: string): Promise<Rule | null> {
-    return this.ruleModel.findOne({ gameType }).exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Rule, RuleDocument } from '..';
+
+@Injectable()
+export class RuleRepository {
+  constructor(@InjectModel(Rule.name) private ruleModel: Model<RuleDocument>) {}
+
+  async findRule(gameType: string): Promise<Rule | null> {
+    return this.ruleModel.findOne({ gameType }).exec();
+  }
+}