jp.db.schemas 1.0.17 → 1.0.19

package/src/index.ts

@@ -30,6 +30,32 @@ import { Banner, BannerSchema } from './schemas/banner.schema';
 import type { BannerDocument } from './schemas/banner.schema';
 import { Server, ServerSchema } from './schemas/server.schema';
 import type { ServerDocument } from './schemas/server.schema';
+import { Achievement, AchievementSchema } from './schemas/achievement.schema';
+import type { AchievementDocument } from './schemas/achievement.schema';
+import { ChannelMessage, ChannelMessageSchema } from './schemas/channel_message.schema';
+import type { ChannelMessageDocument } from './schemas/channel_message.schema';
+import { Feature, FeatureSchema } from './schemas/feature.schema';
+import type { FeatureDocument } from './schemas/feature.schema';
+import { Product, ProductSchema } from './schemas/product.schema';
+import type { ProductDocument } from './schemas/product.schema';
+import { PurchaseChannel, PurchaseChannelSchema } from './schemas/purchase_channel.schema';
+import type { PurchaseChannelDocument } from './schemas/purchase_channel.schema';
+import { Rating, RatingSchema } from './schemas/rating.schema';
+import type { RatingDocument } from './schemas/rating.schema';
+import { Setting, SettingSchema } from './schemas/setting.schema';
+import type { SettingDocument } from './schemas/setting.schema';
+
+import {
+    AdminRepository,
+    ArticleRepository,
+    BannersRepository,
+    ComplainsRepository,
+    NotificationRepository,
+    ProductsRepository,
+    ScheduledTournamentsRepository,
+    ServersRepository,
+    UsersRepository,
+} from './repositories'
 
 export type {
     UserDocument,
@@ -48,6 +74,13 @@ export type {
     ArticleDocument,
     BannerDocument,
     ServerDocument,
+    AchievementDocument,
+    ChannelMessageDocument,
+    FeatureDocument,
+    ProductDocument,
+    PurchaseChannelDocument,
+    RatingDocument,
+    SettingDocument,
 }
 
 export {
@@ -83,4 +116,30 @@ export {
     BannerSchema,
     Server,
     ServerSchema,
+    Achievement,
+    AchievementSchema,
+    ChannelMessage,
+    ChannelMessageSchema,
+    Feature,
+    FeatureSchema,
+    Product,
+    ProductSchema,
+    PurchaseChannel,
+    PurchaseChannelSchema,
+    Rating,
+    RatingSchema,
+    Setting,
+    SettingSchema,
+}
+
+export {
+    AdminRepository,
+    ArticleRepository,
+    BannersRepository,
+    ComplainsRepository,
+    NotificationRepository,
+    ProductsRepository,
+    ScheduledTournamentsRepository,
+    ServersRepository,
+    UsersRepository,
 }

package/src/repositories/admin.repository.ts

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

package/src/repositories/article.repository.ts

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

package/src/repositories/banners.repository.ts

@@ -0,0 +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);
+  }
+}

package/src/repositories/complains.repository.ts

@@ -0,0 +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 };
+  }
+}

package/src/repositories/index.ts

@@ -0,0 +1,21 @@
+import { AdminRepository } from './admin.repository';
+import { ArticleRepository } from './article.repository';
+import { BannersRepository } from './banners.repository';
+import { ComplainsRepository } from './complains.repository';
+import { NotificationRepository } from './notification.repository';
+import { ProductsRepository } from './products.repository';
+import { ScheduledTournamentsRepository } from './scheduled-tournaments.repository';
+import { ServersRepository } from './servers.repository';
+import { UsersRepository } from './users.repository';
+
+export {
+    AdminRepository,
+    ArticleRepository,
+    BannersRepository,
+    ComplainsRepository,
+    NotificationRepository,
+    ProductsRepository,
+    ScheduledTournamentsRepository,
+    ServersRepository,
+    UsersRepository,
+}

package/src/repositories/notification.repository.ts

@@ -0,0 +1,54 @@
+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/products.repository.ts

@@ -0,0 +1,29 @@
+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/scheduled-tournaments.repository.ts

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

package/src/repositories/servers.repository.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { Server, ServerDocument } from '../';
+
+@Injectable()
+export class ServersRepository {
+    constructor (@InjectModel(Server.name) private serverModel: Model<ServerDocument>) {
+    }
+
+    async findServerByName (name: string): Promise<Server | null> {
+        return this.serverModel
+            .findOne({name})
+            .exec();
+    }
+}
+

package/src/repositories/users.repository.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { User, UserDocument } from '../';
+
+function getFullNameFilter (userName: string) {
+    const regexpName = {
+        '$regex': userName,
+        '$options': 'i',
+    };
+
+    return userName ? { $or: [{ fullName: regexpName }, { fullNameAlias: regexpName }] } : {};
+}
+
+@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 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: 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();
+    }
+}

package/src/schemas/achievement.schema.ts

@@ -0,0 +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;
+        },
+    })
+    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/banner.schema.ts

@@ -32,6 +32,9 @@ export class Banner {
 
     @Prop()
     createDate: Date;
+
+    @Prop()
+    game?: string;
 }
 
 export const BannerSchema = SchemaFactory.createForClass(Banner);

package/src/schemas/channel_message.schema.ts

@@ -0,0 +1,31 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type ChannelMessageDocument = HydratedDocument<ChannelMessage>;
+
+@Schema()
+export class ChannelMessage {
+    @Virtual({
+        get: function (this: Document) {
+            return this.id;
+        },
+    })
+    readonly channelMessageId: string;
+
+    @Prop()
+    channelId: string;
+
+    @Prop()
+    date: Date;
+
+    @Prop()
+    text: string;
+
+    @Prop()
+    userId: string;
+
+    @Prop()
+    read: boolean;
+}
+
+export const ChannelMessageSchema = SchemaFactory.createForClass(ChannelMessage);

package/src/schemas/feature.schema.ts

@@ -0,0 +1,28 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type FeatureDocument = HydratedDocument<Feature>;
+
+@Schema()
+export class Feature {
+    @Virtual({
+        get: function (this: Document) {
+            return this.id;
+        },
+    })
+    readonly featureId: string;
+
+    @Prop()
+    name: string;
+
+    @Prop()
+    enabled: boolean;
+
+    @Prop()
+    channels: string;
+
+    @Prop()
+    game?: string;
+}
+
+export const FeatureSchema = SchemaFactory.createForClass(Feature);

package/src/schemas/notification.schema.ts

@@ -53,6 +53,9 @@ export class Notification {
 
     @Prop()
     channels: string;
+
+    @Prop()
+    game?: string;
 }
 
 export const NotificationSchema = SchemaFactory.createForClass(Notification);

package/src/schemas/product.schema.ts

@@ -0,0 +1,123 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type ProductDocument = HydratedDocument<Product>;
+
+@Schema()
+export class Product {
+    @Virtual({
+        get: function (this: Document) {
+            return this.id;
+        },
+    })
+    readonly productId: string;
+
+    @Prop()
+    title: string;
+
+    @Prop()
+    titleEn: string;
+
+    @Prop()
+    subtitle: string;
+
+    @Prop()
+    subtitleEn: string;
+
+    @Prop()
+    description: string;
+
+    @Prop()
+    descriptionEn: string;
+
+    @Prop()
+    descriptionAcquired: string;
+
+    @Prop()
+    descriptionAcquiredEn: string;
+
+    @Prop()
+    buttonAcquired: string;
+
+    @Prop()
+    buttonAcquiredEn: string;
+
+    @Prop()
+    button: string;
+
+    @Prop()
+    buttonEn: string;
+
+    @Prop()
+    link: string;
+
+    @Prop()
+    linkVK: string;
+
+    @Prop()
+    channels: string;
+
+    @Prop()
+    code: string;
+
+    @Prop()
+    position: number;
+
+    @Prop()
+    active: boolean;
+
+    @Prop()
+    image: string;
+
+    @Prop()
+    icon: string;
+
+    @Prop()
+    external: boolean;
+
+    @Prop()
+    isConsumable: boolean;
+
+    // поля для товара
+
+    @Prop()
+    parentId?: string | null;
+
+    @Prop()
+    price?: number;
+
+    @Prop()
+    priceVK?: number;
+
+    @Prop()
+    priceOK?: number;
+
+    @Prop()
+    priceYA?: number;
+
+    @Prop()
+    priceGooglePlay?: number;
+
+    @Prop()
+    priceFB?: number;
+
+    @Prop()
+    priceTG?: number;
+
+    @Prop()
+    priceRuStore?: number;
+
+    @Prop()
+    value?: number;
+
+    @Prop()
+    period?: string;
+
+    @Prop()
+    type?: string;
+
+    @Prop()
+    game?: string;
+}
+
+export const ProductSchema = SchemaFactory.createForClass(Product);