jp.db.schemas 2.0.26 → 2.1.0

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

@@ -1,106 +1,106 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-
-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 findTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
-        return this.tournamentModel
-            .find({ gameType, isTemplate: false })
-            .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 { 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 findTournaments (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
+        return this.tournamentModel
+            .find({ gameType, isTemplate: false })
+            .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.repository.ts

@@ -1,124 +1,124 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import { BulkWriteResult } from 'mongodb';
-
-import { User, UserDocument } from '../';
-
-function getFullNameFilter (userName: string) {
-    const regexpName = {
-        '$regex': userName,
-        '$options': 'i',
-    };
-
-    return userName ? { $or: [{ fullName: regexpName }, { fullNameAlias: regexpName }] } : {};
-}
-
-export type UserGameResultType = {
-    userId: string;
-    balanceAdding: number;
-    experienceAdding: number;
-    levelAdding: number;
-}
-
-@Injectable()
-export class UsersRepository {
-    constructor (@InjectModel(User.name) private userModel: Model<UserDocument>) {
-    }
-
-    async findById (id: string): Promise<User | null> {
-        return this.userModel
-            .findById(id)
-            .exec();
-    }
-
-    async findByVKId (vkId: number): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'vkUser.id': vkId })
-            .exec();
-    }
-
-    async findByOkId (okId: string): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'okUser.uid': okId })
-            .exec();
-    }
-
-    async findByYAId (yaId: string): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'yaUser.userId': yaId })
-            .exec();
-    }
-
-    async findByGoogleId (googleId: string): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'googleUser.userId': googleId })
-            .exec();
-    }
-
-    async findByFBId (fbId: string): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'fbUser.playerId': fbId })
-            .exec();
-    }
-
-    async findByTGId (tgId: number): Promise<User | null> {
-        return this.userModel
-            .findOne({ 'tgUser.id': tgId })
-            .exec();
-    }
-
-    async findAndCount (userName: string, limit: number, skip: number): Promise<{
-        items: Array<User>,
-        total: number
-    }> {
-        const items = await this.userModel
-            .find(getFullNameFilter(userName))
-            .limit(limit)
-            .skip(skip)
-            .exec();
-
-        const total = await this.userModel
-            .find(getFullNameFilter(userName))
-            .countDocuments()
-            .exec();
-
-        return { items, total };
-    }
-
-    async createUser (user: Partial<User>): Promise<User> {
-        return this.userModel.create(user);
-    }
-
-    async updateUser (userId: string, user: Partial<User>, balanceAdding?: number): Promise<UserDocument | null> {
-        delete user.balance;
-
-        return this.userModel.findByIdAndUpdate(
-            userId,
-            {
-                $set: {
-                    ...user,
-                },
-                $inc: { balance: balanceAdding ?? 0 }
-            },
-            { new: true },
-        ).exec();
-    }
-
-    async saveGameResult (usersBalances: Array<UserGameResultType>): Promise<BulkWriteResult> {
-        return this.userModel.bulkWrite(
-            usersBalances.map((item) => ({
-                updateOne: {
-                    filter: { _id: item.userId },
-                    update: {
-                        $inc: {
-                            balance: item.balanceAdding,
-                            experience: item.experienceAdding,
-                            level: item.levelAdding,
-                        }
-                    },
-                },
-            })),
-        );
-    }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BulkWriteResult } from 'mongodb';
+
+import { User, UserDocument } from '../';
+
+function getFullNameFilter (userName: string) {
+    const regexpName = {
+        '$regex': userName,
+        '$options': 'i',
+    };
+
+    return userName ? { $or: [{ fullName: regexpName }, { fullNameAlias: regexpName }] } : {};
+}
+
+export type UserGameResultType = {
+    userId: string;
+    balanceAdding: number;
+    experienceAdding: number;
+    levelAdding: number;
+}
+
+@Injectable()
+export class UsersRepository {
+    constructor (@InjectModel(User.name) private userModel: Model<UserDocument>) {
+    }
+
+    async findById (id: string): Promise<User | null> {
+        return this.userModel
+            .findById(id)
+            .exec();
+    }
+
+    async findByVKId (vkId: number): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'vkUser.id': vkId })
+            .exec();
+    }
+
+    async findByOkId (okId: string): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'okUser.uid': okId })
+            .exec();
+    }
+
+    async findByYAId (yaId: string): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'yaUser.userId': yaId })
+            .exec();
+    }
+
+    async findByGoogleId (googleId: string): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'googleUser.userId': googleId })
+            .exec();
+    }
+
+    async findByFBId (fbId: string): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'fbUser.playerId': fbId })
+            .exec();
+    }
+
+    async findByTGId (tgId: number): Promise<User | null> {
+        return this.userModel
+            .findOne({ 'tgUser.id': tgId })
+            .exec();
+    }
+
+    async findAndCount (userName: string, limit: number, skip: number): Promise<{
+        items: Array<User>,
+        total: number
+    }> {
+        const items = await this.userModel
+            .find(getFullNameFilter(userName))
+            .limit(limit)
+            .skip(skip)
+            .exec();
+
+        const total = await this.userModel
+            .find(getFullNameFilter(userName))
+            .countDocuments()
+            .exec();
+
+        return { items, total };
+    }
+
+    async createUser (user: Partial<User>): Promise<User> {
+        return this.userModel.create(user);
+    }
+
+    async updateUser (userId: string, user: Partial<User>, balanceAdding?: number): Promise<UserDocument | null> {
+        delete user.balance;
+
+        return this.userModel.findByIdAndUpdate(
+            userId,
+            {
+                $set: {
+                    ...user,
+                },
+                $inc: { balance: balanceAdding ?? 0 }
+            },
+            { new: true },
+        ).exec();
+    }
+
+    async saveGameResult (usersBalances: Array<UserGameResultType>): Promise<BulkWriteResult> {
+        return this.userModel.bulkWrite(
+            usersBalances.map((item) => ({
+                updateOne: {
+                    filter: { _id: item.userId },
+                    update: {
+                        $inc: {
+                            balance: item.balanceAdding,
+                            experience: item.experienceAdding,
+                            level: item.levelAdding,
+                        }
+                    },
+                },
+            })),
+        );
+    }
+}

package/src/repositories/welcome.repository.ts

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

package/src/schemas/achievement.schema.ts

@@ -1,40 +1,40 @@
-import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
-import { Document, HydratedDocument } from 'mongoose';
-
-export type AchievementDocument = HydratedDocument<Achievement>;
-
-@Schema()
-export class Achievement {
-    @Virtual({
-        get: function (this: Document) {
-            return this._id.toString();
-        },
-    })
-    readonly achievementId: string;
-
-    @Prop()
-    title: string;
-
-    @Prop()
-    titleEn: string;
-
-    @Prop()
-    description: string;
-
-    @Prop()
-    descriptionEn: string;
-
-    @Prop()
-    code: string;
-
-    @Prop()
-    vkId: string;
-
-    @Prop()
-    prize: number;
-
-    @Prop()
-    game?: string;
-}
-
-export const AchievementSchema = SchemaFactory.createForClass(Achievement);
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type AchievementDocument = HydratedDocument<Achievement>;
+
+@Schema()
+export class Achievement {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly achievementId: string;
+
+    @Prop()
+    title: string;
+
+    @Prop()
+    titleEn: string;
+
+    @Prop()
+    description: string;
+
+    @Prop()
+    descriptionEn: string;
+
+    @Prop()
+    code: string;
+
+    @Prop()
+    vkId: string;
+
+    @Prop()
+    prize: number;
+
+    @Prop()
+    game?: string;
+}
+
+export const AchievementSchema = SchemaFactory.createForClass(Achievement);

package/src/schemas/activity_log.schema.ts

@@ -0,0 +1,37 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type ActivityLogDocument = HydratedDocument<ActivityLog>;
+
+@Schema({ collection: 'activity_log' })
+export class ActivityLog {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly activityLogId: string;
+
+    @Prop()
+    date: Date;
+
+    @Prop()
+    event: string;
+
+    @Prop()
+    userId: string;
+
+    @Prop()
+    userName: string;
+
+    @Prop()
+    amount?: number;
+
+    @Prop()
+    game: string;
+
+    @Prop()
+    channel: string;
+}
+
+export const ActivityLogSchema = SchemaFactory.createForClass(ActivityLog);

package/src/schemas/admin.schema.ts

@@ -1,22 +1,22 @@
-import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
-import { Document, HydratedDocument } from 'mongoose';
-
-export type AdminDocument = HydratedDocument<Admin>;
-
-@Schema()
-export class Admin {
-    @Virtual({
-        get: function (this: Document) {
-            return this._id.toString();
-        },
-    })
-    readonly adminId: string;
-
-    @Prop()
-    login: string;
-
-    @Prop()
-    pass: string;
-}
-
-export const AdminSchema = SchemaFactory.createForClass(Admin);
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type AdminDocument = HydratedDocument<Admin>;
+
+@Schema()
+export class Admin {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly adminId: string;
+
+    @Prop()
+    login: string;
+
+    @Prop()
+    pass: string;
+}
+
+export const AdminSchema = SchemaFactory.createForClass(Admin);