jp.db.schemas 2.1.13 → 2.1.14

package/src/repositories/achievement.repository.ts

@@ -1,18 +1,18 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Achievement, AchievementDocument } from '..';
-
-@Injectable()
-export class AchievementRepository {
-    constructor (@InjectModel(Achievement.name) private menuModel: Model<AchievementDocument>) {
-    }
-
-    async findAchievements (): Promise<Array<Achievement>> {
-        return this.menuModel
-            .find()
-            .exec();
-    }
-}
-
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Achievement, AchievementDocument } from '..';
+
+@Injectable()
+export class AchievementRepository {
+    constructor (@InjectModel(Achievement.name) private menuModel: Model<AchievementDocument>) {
+    }
+
+    async findAchievements (): Promise<Array<Achievement>> {
+        return this.menuModel
+            .find()
+            .exec();
+    }
+}
+

package/src/repositories/activity-log.repository.ts

@@ -1,110 +1,110 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import dayjs from 'dayjs';
-
-import { ActivityLog, ActivityLogDocument } from '..';
-import { ActivityLogEnum } from '../models/activity-log.enum';
-import { IActivityLogUserLogin } from '../models/activity-log-user-login.interface';
-
-@Injectable()
-export class ActivityLogRepository {
-    constructor(
-        @InjectModel(ActivityLog.name) private activityLogModel: Model<ActivityLogDocument>
-    ) {
-    }
-
-    async findLast7DaysLogins(
-        game: string,
-        userId: string,
-    ): Promise<Array<IActivityLogUserLogin>> {
-        const weekAgo = dayjs().startOf('day').add(-1, 'week');
-
-        return this.activityLogModel.aggregate([
-            {
-                $match: {
-                    game,
-                    userId,
-                    date: { $gte: weekAgo.toDate() },
-                    event: ActivityLogEnum.USER_LOGIN,
-                }
-            },
-            {
-                $group: {
-                    _id: { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
-                    userId: { $first: "$userId" },
-                    userName: { $first: "$userName" },
-                    event: { $first: "$event" },
-                    game: { $first: "$game" },
-                    channels: { $first: "$channels" },
-                    count: { $sum: 1 },
-                }
-            },
-            {
-                $project: {
-                    _id: 0,
-                    id: "$_id",
-                    userId: 1,
-                    userName: 1,
-                    event: 1,
-                    game: 1,
-                    channel: 1,
-                    count: 1,
-                    date: "$_id"
-                }
-            },
-            {
-                $sort: { "date": -1 }
-            }
-        ])
-    }
-
-    async userIsNewbie(userId: string): Promise<boolean> {
-        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_LOGIN }).exec() === 1;
-    }
-
-    async getUserPlayedGamesCount(userId: string): Promise<number> {
-        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_PLAYED_GAME }).exec()
-    }
-
-    async getUserWonGamesCount(userId: string): Promise<number> {
-        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_GAME }).exec()
-    }
-
-    async getUserWonProfiCount(userId: string): Promise<number> {
-        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_PROFI }).exec()
-    }
-
-    async getUserWonOneTableTournamentCount(userId: string): Promise<number> {
-        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_ONE_TABLE_TOURNAMENT }).exec()
-    }
-
-    async addUserLoginEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_LOGIN, userId, userName, game, channels });
-    }
-
-    async addUserGotBonuseEvent(userId: string, userName: string, game: string, channels: string, amount: number): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_GOT_BONUS, userId, userName, game, channels, amount, });
-    }
-
-    async addUserPlayedGameEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_PLAYED_GAME, userId, userName, game, channels, });
-    }
-
-    async addUserWonGameEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_GAME, userId, userName, game, channels });
-    }
-
-    async addUserWonProfieEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_PROFI, userId, userName, game, channels });
-    }
-
-    async addUserWonOneTableTournamentEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_ONE_TABLE_TOURNAMENT, userId, userName, game, channels });
-    }
-
-    async addActivityLog(activityLog: Partial<ActivityLog>): Promise<ActivityLog> {
-        return this.activityLogModel.create(activityLog);
-    }
-}
-
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import dayjs from 'dayjs';
+
+import { ActivityLog, ActivityLogDocument } from '..';
+import { ActivityLogEnum } from '../models/activity-log.enum';
+import { IActivityLogUserLogin } from '../models/activity-log-user-login.interface';
+
+@Injectable()
+export class ActivityLogRepository {
+    constructor(
+        @InjectModel(ActivityLog.name) private activityLogModel: Model<ActivityLogDocument>
+    ) {
+    }
+
+    async findLast7DaysLogins(
+        game: string,
+        userId: string,
+    ): Promise<Array<IActivityLogUserLogin>> {
+        const weekAgo = dayjs().startOf('day').add(-1, 'week');
+
+        return this.activityLogModel.aggregate([
+            {
+                $match: {
+                    game,
+                    userId,
+                    date: { $gte: weekAgo.toDate() },
+                    event: ActivityLogEnum.USER_LOGIN,
+                }
+            },
+            {
+                $group: {
+                    _id: { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
+                    userId: { $first: "$userId" },
+                    userName: { $first: "$userName" },
+                    event: { $first: "$event" },
+                    game: { $first: "$game" },
+                    channels: { $first: "$channels" },
+                    count: { $sum: 1 },
+                }
+            },
+            {
+                $project: {
+                    _id: 0,
+                    id: "$_id",
+                    userId: 1,
+                    userName: 1,
+                    event: 1,
+                    game: 1,
+                    channel: 1,
+                    count: 1,
+                    date: "$_id"
+                }
+            },
+            {
+                $sort: { "date": -1 }
+            }
+        ])
+    }
+
+    async userIsNewbie(userId: string): Promise<boolean> {
+        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_LOGIN }).exec() === 1;
+    }
+
+    async getUserPlayedGamesCount(userId: string): Promise<number> {
+        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_PLAYED_GAME }).exec()
+    }
+
+    async getUserWonGamesCount(userId: string): Promise<number> {
+        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_GAME }).exec()
+    }
+
+    async getUserWonProfiCount(userId: string): Promise<number> {
+        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_PROFI }).exec()
+    }
+
+    async getUserWonOneTableTournamentCount(userId: string): Promise<number> {
+        return await this.activityLogModel.countDocuments({ userId, event: ActivityLogEnum.USER_WON_ONE_TABLE_TOURNAMENT }).exec()
+    }
+
+    async addUserLoginEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_LOGIN, userId, userName, game, channels });
+    }
+
+    async addUserGotBonuseEvent(userId: string, userName: string, game: string, channels: string, amount: number): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_GOT_BONUS, userId, userName, game, channels, amount, });
+    }
+
+    async addUserPlayedGameEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_PLAYED_GAME, userId, userName, game, channels, });
+    }
+
+    async addUserWonGameEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_GAME, userId, userName, game, channels });
+    }
+
+    async addUserWonProfieEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_PROFI, userId, userName, game, channels });
+    }
+
+    async addUserWonOneTableTournamentEvent(userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
+        return this.addActivityLog({ date: new Date(), event: ActivityLogEnum.USER_WON_ONE_TABLE_TOURNAMENT, userId, userName, game, channels });
+    }
+
+    async addActivityLog(activityLog: Partial<ActivityLog>): Promise<ActivityLog> {
+        return this.activityLogModel.create(activityLog);
+    }
+}
+

package/src/repositories/admin.repository.ts

@@ -1,23 +1,23 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Admin, AdminDocument } from '../';
-
-@Injectable()
-export class AdminRepository {
-  constructor (@InjectModel(Admin.name) private adminModel: Model<AdminDocument>) {
-  }
-
-  async findById (id: string): Promise<Admin | null> {
-    return this.adminModel
-      .findOne({ _id: id })
-      .exec();
-  }
-
-  async findByLogin (login: string): Promise<Admin | null> {
-    return this.adminModel
-      .findOne({ login })
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Admin, AdminDocument } from '../';
+
+@Injectable()
+export class AdminRepository {
+  constructor (@InjectModel(Admin.name) private adminModel: Model<AdminDocument>) {
+  }
+
+  async findById (id: string): Promise<Admin | null> {
+    return this.adminModel
+      .findOne({ _id: id })
+      .exec();
+  }
+
+  async findByLogin (login: string): Promise<Admin | null> {
+    return this.adminModel
+      .findOne({ login })
+      .exec();
+  }
+}

package/src/repositories/article.repository.ts

@@ -1,33 +1,33 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Article, ArticleDocument } from '../';
-
-@Injectable()
-export class ArticleRepository {
-  constructor (@InjectModel(Article.name) private articleModel: Model<ArticleDocument>) {
-  }
-
-  async findAllArticles (): Promise<Array<Article>> {
-    return this.articleModel
-      .find()
-      .sort({ createDate: -1 })
-      .exec();
-  }
-
-  async findLastArticle (): Promise<Article | null> {
-    return await this.articleModel
-      .findOne()
-      .sort({ createDate: -1 })
-      .exec();
-  }
-
-  async findTop3Articles (): Promise<Array<Article>> {
-    return this.articleModel
-      .find()
-      .sort({ createDate: -1 })
-      .limit(3)
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Article, ArticleDocument } from '../';
+
+@Injectable()
+export class ArticleRepository {
+  constructor (@InjectModel(Article.name) private articleModel: Model<ArticleDocument>) {
+  }
+
+  async findAllArticles (): Promise<Array<Article>> {
+    return this.articleModel
+      .find()
+      .sort({ createDate: -1 })
+      .exec();
+  }
+
+  async findLastArticle (): Promise<Article | null> {
+    return await this.articleModel
+      .findOne()
+      .sort({ createDate: -1 })
+      .exec();
+  }
+
+  async findTop3Articles (): Promise<Array<Article>> {
+    return this.articleModel
+      .find()
+      .sort({ createDate: -1 })
+      .limit(3)
+      .exec();
+  }
+}

package/src/repositories/balance-history.repository.ts

@@ -1,15 +1,15 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { BalanceHistory, BalanceHistoryDocument } from '../';
-
-@Injectable()
-export class BalanceHistoryRepository {
-    constructor (@InjectModel(BalanceHistory.name) private balanceHistoryModel: Model<BalanceHistoryDocument>) {
-    }
-
-    public async createBalanceHistory (gameResult: Partial<BalanceHistory>): Promise<BalanceHistory> {
-        return this.balanceHistoryModel.create(gameResult);
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { BalanceHistory, BalanceHistoryDocument } from '../';
+
+@Injectable()
+export class BalanceHistoryRepository {
+    constructor (@InjectModel(BalanceHistory.name) private balanceHistoryModel: Model<BalanceHistoryDocument>) {
+    }
+
+    public async createBalanceHistory (gameResult: Partial<BalanceHistory>): Promise<BalanceHistory> {
+        return this.balanceHistoryModel.create(gameResult);
+    }
+}

package/src/repositories/banners.repository.ts

@@ -1,54 +1,54 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Banner, BannerDocument } from '../';
-
-@Injectable()
-export class BannersRepository {
-  constructor (@InjectModel(Banner.name) private bannerModel: Model<BannerDocument>) {
-  }
-
-  async findById (id: string): Promise<Banner | null> {
-    return this.bannerModel
-      .findById(id)
-      .exec();
-  }
-
-  async findAndCount (limit: number, skip: number): Promise<{
-    items: Array<Banner>,
-    total: number
-  }> {
-    const items = await this.bannerModel
-      .find()
-      .sort({ createDate: -1 })
-      .limit(limit)
-      .skip(skip)
-      .exec();
-
-    const total = await this.bannerModel
-      .find()
-      .countDocuments()
-      .exec();
-
-    return { items, total };
-  }
-
-  public async createBanner (banner: Banner): Promise<Banner> {
-    return this.bannerModel.create(banner);
-  }
-
-  async updateBanner (bannerId: string, banner: Partial<Banner>): Promise<void> {
-    await this.bannerModel.findByIdAndUpdate(
-      bannerId,
-      {
-        $set: {
-          ...banner,
-        },
-      }).exec();
-  }
-
-  public async removeBanner (bannerId: string): Promise<void> {
-    await this.bannerModel.findByIdAndDelete(bannerId);
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Banner, BannerDocument } from '../';
+
+@Injectable()
+export class BannersRepository {
+  constructor (@InjectModel(Banner.name) private bannerModel: Model<BannerDocument>) {
+  }
+
+  async findById (id: string): Promise<Banner | null> {
+    return this.bannerModel
+      .findById(id)
+      .exec();
+  }
+
+  async findAndCount (limit: number, skip: number): Promise<{
+    items: Array<Banner>,
+    total: number
+  }> {
+    const items = await this.bannerModel
+      .find()
+      .sort({ createDate: -1 })
+      .limit(limit)
+      .skip(skip)
+      .exec();
+
+    const total = await this.bannerModel
+      .find()
+      .countDocuments()
+      .exec();
+
+    return { items, total };
+  }
+
+  public async createBanner (banner: Banner): Promise<Banner> {
+    return this.bannerModel.create(banner);
+  }
+
+  async updateBanner (bannerId: string, banner: Partial<Banner>): Promise<void> {
+    await this.bannerModel.findByIdAndUpdate(
+      bannerId,
+      {
+        $set: {
+          ...banner,
+        },
+      }).exec();
+  }
+
+  public async removeBanner (bannerId: string): Promise<void> {
+    await this.bannerModel.findByIdAndDelete(bannerId);
+  }
+}

package/src/repositories/complains.repository.ts

@@ -1,30 +1,30 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Complain, ComplainDocument } from '../';
-
-@Injectable()
-export class ComplainsRepository {
-  constructor (@InjectModel(Complain.name) private complainModel: Model<ComplainDocument>) {
-  }
-
-  async findAndCount (limit: number, skip: number): Promise<{
-    items: Array<Complain>,
-    total: number
-  }> {
-    const items = await this.complainModel
-      .find()
-      .sort({ createDate: -1 })
-      .limit(limit)
-      .skip(skip)
-      .exec();
-
-    const total = await this.complainModel
-      .find()
-      .countDocuments()
-      .exec();
-
-    return { items, total };
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Complain, ComplainDocument } from '../';
+
+@Injectable()
+export class ComplainsRepository {
+  constructor (@InjectModel(Complain.name) private complainModel: Model<ComplainDocument>) {
+  }
+
+  async findAndCount (limit: number, skip: number): Promise<{
+    items: Array<Complain>,
+    total: number
+  }> {
+    const items = await this.complainModel
+      .find()
+      .sort({ createDate: -1 })
+      .limit(limit)
+      .skip(skip)
+      .exec();
+
+    const total = await this.complainModel
+      .find()
+      .countDocuments()
+      .exec();
+
+    return { items, total };
+  }
+}

package/src/repositories/daily-bonus.repository.ts

@@ -1,26 +1,26 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { DailyBonus, DailyBonusDocument } from '../';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class DailyBonusRepository {
-    constructor(@InjectModel(DailyBonus.name) private dailyBonusModel: Model<DailyBonusDocument>) {
-    }
-
-    async findDailyBonuses(channel: string, game: string): Promise<Array<DailyBonus> | null> {
-        return this.dailyBonusModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
-
-    async findDailyBonusByDay(day: number, game: string): Promise<DailyBonus | null> {
-        return this.dailyBonusModel
-            .findOne({ game, position: day })
-            .exec();
-    }
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { DailyBonus, DailyBonusDocument } from '../';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class DailyBonusRepository {
+    constructor(@InjectModel(DailyBonus.name) private dailyBonusModel: Model<DailyBonusDocument>) {
+    }
+
+    async findDailyBonuses(channel: string, game: string): Promise<Array<DailyBonus> | null> {
+        return this.dailyBonusModel
+            .find({
+                channels: getChannelRegExpFilter(channel),
+            })
+            .exec();
+    }
+
+    async findDailyBonusByDay(day: number, game: string): Promise<DailyBonus | null> {
+        return this.dailyBonusModel
+            .findOne({ game, position: day })
+            .exec();
+    }
 }

package/src/repositories/friend.repository.ts

@@ -1,20 +1,20 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-import { Friend, FriendDocument } from '..';
-import { getChannelRegExpFilter } from '../utils';
-
-@Injectable()
-export class FriendRepository {
-    constructor (@InjectModel(Friend.name) private friendModel: Model<FriendDocument>) {
-    }
-
-    async findFriend (channel: string, game: string): Promise<Array<Friend> | null> {
-        return this.friendModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Friend, FriendDocument } from '..';
+import { getChannelRegExpFilter } from '../utils';
+
+@Injectable()
+export class FriendRepository {
+    constructor (@InjectModel(Friend.name) private friendModel: Model<FriendDocument>) {
+    }
+
+    async findFriend (channel: string, game: string): Promise<Array<Friend> | null> {
+        return this.friendModel
+            .find({
+                channels: getChannelRegExpFilter(channel),
+            })
+            .exec();
+    }
 }