jp.db.schemas 2.2.9 → 2.2.11

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

@@ -9,116 +9,201 @@ import { IActivityLogUserLogin } from '../models/activity-log-user-login.interfa
 
 @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 getUserTodayBonus (userId: string): Promise<number> {
-        const log = await this.activityLogModel.findOne(
-            {
-                userId,
-                event: ActivityLogEnum.USER_GOT_BONUS,
-                date: {
-                    $gte: dayjs().startOf('day').toDate(),
-                    $lte: dayjs().endOf('day').toDate(),
-                },
-            }).exec();
-
-        return log?.amount ?? 0;
-    }
-
-    async addUserLoginEvent (userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ 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({ 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({ event: ActivityLogEnum.USER_PLAYED_GAME, userId, userName, game, channels, });
-    }
-
-    async addUserWonGameEvent (userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ event: ActivityLogEnum.USER_WON_GAME, userId, userName, game, channels });
-    }
-
-    async addUserWonProfieEvent (userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ event: ActivityLogEnum.USER_WON_PROFI, userId, userName, game, channels });
-    }
-
-    async addUserWonOneTableTournamentEvent (userId: string, userName: string, game: string, channels: string): Promise<ActivityLog> {
-        return this.addActivityLog({ event: ActivityLogEnum.USER_WON_ONE_TABLE_TOURNAMENT, userId, userName, game, channels });
-    }
-
-    async addActivityLog (activityLog: Partial<ActivityLog>): Promise<ActivityLog> {
-        return this.activityLogModel.create(activityLog);
-    }
+  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 getUserTodayBonus(userId: string): Promise<number> {
+    const log = await this.activityLogModel
+      .findOne({
+        userId,
+        event: ActivityLogEnum.USER_GOT_BONUS,
+        date: {
+          $gte: dayjs().startOf('day').toDate(),
+          $lte: dayjs().endOf('day').toDate(),
+        },
+      })
+      .exec();
+
+    return log?.amount ?? 0;
+  }
+
+  async addUserLoginEvent(
+    userId: string,
+    userName: string,
+    game: string,
+    channels: string,
+  ): Promise<ActivityLog> {
+    return this.addActivityLog({
+      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({
+      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({
+      event: ActivityLogEnum.USER_PLAYED_GAME,
+      userId,
+      userName,
+      game,
+      channels,
+    });
+  }
+
+  async addUserWonGameEvent(
+    userId: string,
+    userName: string,
+    game: string,
+    channels: string,
+  ): Promise<ActivityLog> {
+    return this.addActivityLog({
+      event: ActivityLogEnum.USER_WON_GAME,
+      userId,
+      userName,
+      game,
+      channels,
+    });
+  }
+
+  async addUserWonProfieEvent(
+    userId: string,
+    userName: string,
+    game: string,
+    channels: string,
+  ): Promise<ActivityLog> {
+    return this.addActivityLog({
+      event: ActivityLogEnum.USER_WON_PROFI,
+      userId,
+      userName,
+      game,
+      channels,
+    });
+  }
+
+  async addUserWonOneTableTournamentEvent(
+    userId: string,
+    userName: string,
+    game: string,
+    channels: string,
+  ): Promise<ActivityLog> {
+    return this.addActivityLog({
+      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

@@ -6,18 +6,15 @@ import { Admin, AdminDocument } from '../';
 
 @Injectable()
 export class AdminRepository {
-  constructor (@InjectModel(Admin.name) private adminModel: Model<AdminDocument>) {
-  }
+  constructor(
+    @InjectModel(Admin.name) private adminModel: Model<AdminDocument>,
+  ) {}
 
-  async findById (id: string): Promise<Admin | null> {
-    return this.adminModel
-      .findOne({ _id: id })
-      .exec();
+  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();
+  async findByLogin(login: string): Promise<Admin | null> {
+    return this.adminModel.findOne({ login }).exec();
   }
 }

package/src/repositories/article.repository.ts

@@ -6,28 +6,19 @@ import { Article, ArticleDocument } from '../';
 
 @Injectable()
 export class ArticleRepository {
-  constructor (@InjectModel(Article.name) private articleModel: Model<ArticleDocument>) {
-  }
+  constructor(
+    @InjectModel(Article.name) private articleModel: Model<ArticleDocument>,
+  ) {}
 
-  async findAllArticles (): Promise<Array<Article>> {
-    return this.articleModel
-      .find()
-      .sort({ createDate: -1 })
-      .exec();
+  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 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();
+  async findTop3Articles(): Promise<Array<Article>> {
+    return this.articleModel.find().sort({ createDate: -1 }).limit(3).exec();
   }
 }

package/src/repositories/banners.repository.ts

@@ -6,24 +6,27 @@ import { Banner, BannerDocument } from '../';
 
 @Injectable()
 export class BannersRepository {
-  constructor(@InjectModel(Banner.name) private bannerModel: Model<BannerDocument>) {
+  constructor(
+    @InjectModel(Banner.name) private bannerModel: Model<BannerDocument>,
+  ) {}
+
+  async findEnabledBanner(
+    game: string,
+    channels: string,
+  ): Promise<Banner | null> {
+    return this.bannerModel.findOne({ enabled: true }).exec();
   }
 
-  async findEnabledBanner (game: string, channels: string): Promise<Banner | null> {
-    return this.bannerModel
-      .findOne({ enabled: true })
-      .exec();
-  }
-
-  async findById (id: string): Promise<Banner | null> {
-    return this.bannerModel
-      .findById(id)
-      .exec();
+  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
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<Banner>;
+    total: number;
   }> {
     const items = await this.bannerModel
       .find()
@@ -32,29 +35,26 @@ export class BannersRepository {
       .skip(skip)
       .exec();
 
-    const total = await this.bannerModel
-      .find()
-      .countDocuments()
-      .exec();
+    const total = await this.bannerModel.find().countDocuments().exec();
 
     return { items, total };
   }
 
-  public async createBanner (banner: Banner): Promise<Banner> {
+  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,
-      {
+  async updateBanner(bannerId: string, banner: Partial<Banner>): Promise<void> {
+    await this.bannerModel
+      .findByIdAndUpdate(bannerId, {
         $set: {
           ...banner,
         },
-      }).exec();
+      })
+      .exec();
   }
 
-  public async removeBanner (bannerId: string): Promise<void> {
+  public async removeBanner(bannerId: string): Promise<void> {
     await this.bannerModel.findByIdAndDelete(bannerId);
   }
 }

package/src/repositories/complains.repository.ts

@@ -6,12 +6,16 @@ import { Complain, ComplainDocument } from '../';
 
 @Injectable()
 export class ComplainsRepository {
-  constructor (@InjectModel(Complain.name) private complainModel: Model<ComplainDocument>) {
-  }
+  constructor(
+    @InjectModel(Complain.name) private complainModel: Model<ComplainDocument>,
+  ) {}
 
-  async findAndCount (limit: number, skip: number): Promise<{
-    items: Array<Complain>,
-    total: number
+  async findAndCount(
+    limit: number,
+    skip: number,
+  ): Promise<{
+    items: Array<Complain>;
+    total: number;
   }> {
     const items = await this.complainModel
       .find()
@@ -20,10 +24,7 @@ export class ComplainsRepository {
       .skip(skip)
       .exec();
 
-    const total = await this.complainModel
-      .find()
-      .countDocuments()
-      .exec();
+    const total = await this.complainModel.find().countDocuments().exec();
 
     return { items, total };
   }

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

@@ -7,20 +7,26 @@ import { getChannelRegExpFilter } from '../utils';
 
 @Injectable()
 export class DailyBonusRepository {
-    constructor(@InjectModel(DailyBonus.name) private dailyBonusModel: Model<DailyBonusDocument>) {
-    }
+  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 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();
-    }
-}
+  async findDailyBonusByDay(
+    day: number,
+    game: string,
+  ): Promise<DailyBonus | null> {
+    return this.dailyBonusModel.findOne({ game, position: day }).exec();
+  }
+}

package/src/repositories/friend.repository.ts

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

package/src/repositories/game-result.repository.ts

@@ -6,10 +6,14 @@ import { GameResult, GameResultDocument } from '../';
 
 @Injectable()
 export class GameResultRepository {
-    constructor (@InjectModel(GameResult.name) private gameResultModel: Model<GameResultDocument>) {
-    }
+  constructor(
+    @InjectModel(GameResult.name)
+    private gameResultModel: Model<GameResultDocument>,
+  ) {}
 
-    public async createGameResult (gameResult: Partial<GameResult>): Promise<GameResult> {
-        return this.gameResultModel.create(gameResult);
-    }
+  public async createGameResult(
+    gameResult: Partial<GameResult>,
+  ): Promise<GameResult> {
+    return this.gameResultModel.create(gameResult);
+  }
 }

package/src/repositories/game-statistic.repository.ts

@@ -7,15 +7,19 @@ import { getChannelRegExpFilter } from '../utils';
 
 @Injectable()
 export class GameStatisticRepository {
-    constructor (@InjectModel(GameStatistic.name) private gameStatisticModel: Model<GameStatisticDocument>) {
-    }
+  constructor(
+    @InjectModel(GameStatistic.name)
+    private gameStatisticModel: Model<GameStatisticDocument>,
+  ) {}
 
-    async findGameStatistic (channel: string, game: string): Promise<Array<GameStatistic> | null> {
-        return this.gameStatisticModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
-            .exec();
-    }
+  async findGameStatistic(
+    channel: string,
+    game: string,
+  ): Promise<Array<GameStatistic> | null> {
+    return this.gameStatisticModel
+      .find({
+        channels: getChannelRegExpFilter(channel),
+      })
+      .exec();
+  }
 }
-