jp.db.schemas 2.0.1 → 2.0.2

package/src/index.ts

@@ -50,6 +50,14 @@ import { GameResult, GameResultSchema } from './schemas/game_result.schema';
 import type { GameResultDocument } from './schemas/game_result.schema';
 import { BalanceHistory, BalanceHistorySchema } from './schemas/balance_history.schema';
 import type { BalanceHistoryDocument } from './schemas/balance_history.schema';
+import { SimpleRoom, SimpleRoomSchema } from './schemas/simple_rooms.schema';
+import type { SimpleRoomDocument } from './schemas/simple_rooms.schema';
+import { TournamentOneTableRoom, TournamentOneTableRoomSchema, } from './schemas/tournament_one_table_rooms.schema';
+import type { TournamentOneTableRoomDocument } from './schemas/tournament_one_table_rooms.schema';
+import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema } from './schemas/tournament_many_tables_rooms.schema';
+import type { TournamentManyTablesRoomDocument } from './schemas/tournament_many_tables_rooms.schema';
+import { TournamentResult, TournamentResultSchema } from './schemas/tournament_result.schema';
+import type { TournamentResultDocument } from './schemas/tournament_result.schema';
 
 import {
     AdminRepository,
@@ -65,6 +73,10 @@ import {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
+    TournamentResultRepository,
 } from './repositories'
 
 export type {
@@ -94,6 +106,10 @@ export type {
     MenuDocument,
     GameResultDocument,
     BalanceHistoryDocument,
+    SimpleRoomDocument,
+    TournamentOneTableRoomDocument,
+    TournamentManyTablesRoomDocument,
+    TournamentResultDocument,
 }
 
 export {
@@ -149,6 +165,14 @@ export {
     GameResultSchema,
     BalanceHistory,
     BalanceHistorySchema,
+    SimpleRoom,
+    SimpleRoomSchema,
+    TournamentOneTableRoom,
+    TournamentOneTableRoomSchema,
+    TournamentManyTablesRoom,
+    TournamentManyTablesRoomSchema,
+    TournamentResult,
+    TournamentResultSchema,
 }
 
 export {
@@ -165,4 +189,8 @@ export {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
+    TournamentResultRepository,
 }

package/src/repositories/index.ts

@@ -11,6 +11,10 @@ import { MenuRepository } from './menu.repository';
 import { RoomsRepository } from './rooms.repository';
 import { GameResultRepository } from './game-result.repository';
 import { BalanceHistoryRepository } from './balance-history.repository';
+import { SimpleRoomsRepository } from './simple-rooms.repository';
+import { TournamentOneTableRoomsRepository } from './tournament-one-table-rooms.repository';
+import { TournamentManyTablesRoomsRepository } from './tournament-many-tables-rooms.repository';
+import { TournamentResultRepository } from './tournament-result.repository';
 
 export {
     AdminRepository,
@@ -26,4 +30,8 @@ export {
     RoomsRepository,
     GameResultRepository,
     BalanceHistoryRepository,
+    SimpleRoomsRepository,
+    TournamentOneTableRoomsRepository,
+    TournamentManyTablesRoomsRepository,
+    TournamentResultRepository,
 }

package/src/repositories/simple-rooms.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { SimpleRoom, SimpleRoomDocument } from '../';
+
+@Injectable()
+export class SimpleRoomsRepository {
+    constructor (@InjectModel(SimpleRoom.name) private roomModel: Model<SimpleRoomDocument>) {
+    }
+
+    async findRooms (gameType: string): Promise<Array<SimpleRoomDocument>> {
+        return this.roomModel
+            .find({ gameType })
+            .exec();
+    }
+}

package/src/repositories/tournament-many-tables-rooms.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { TournamentManyTablesRoom, TournamentManyTablesRoomDocument } from '../';
+
+@Injectable()
+export class TournamentManyTablesRoomsRepository {
+    constructor (@InjectModel(TournamentManyTablesRoom.name) private roomModel: Model<TournamentManyTablesRoomDocument>) {
+    }
+
+    async findRooms (gameType: string): Promise<Array<TournamentManyTablesRoomDocument>> {
+        return this.roomModel
+            .find({ gameType })
+            .exec();
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { TournamentOneTableRoom, TournamentOneTableRoomDocument } from '../';
+
+@Injectable()
+export class TournamentOneTableRoomsRepository {
+    constructor (@InjectModel(TournamentOneTableRoom.name) private roomModel: Model<TournamentOneTableRoomDocument>) {
+    }
+
+    async findRooms (gameType: string): Promise<Array<TournamentOneTableRoomDocument>> {
+        return this.roomModel
+            .find({ gameType })
+            .exec();
+    }
+}

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

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { TournamentResult, TournamentResultDocument, User } from '../';
+
+@Injectable()
+export class TournamentResultRepository {
+    constructor (@InjectModel(TournamentResult.name) private resultModel: Model<TournamentResultDocument>) {
+    }
+
+    async findByTournamentId (tournamentId: string): Promise<TournamentResultDocument | null> {
+        return this.resultModel
+            .findOne({ tournamentId })
+            .exec();
+    }
+
+    async createResult (result: Partial<TournamentResult>): Promise<TournamentResult> {
+        return this.resultModel.create(result);
+    }
+}

package/src/schemas/simple_rooms.schema.ts

@@ -0,0 +1,43 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type SimpleRoomDocument = HydratedDocument<SimpleRoom>;
+
+@Schema({ collection: 'simple_rooms' })
+export class SimpleRoom {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly roomId: string;
+
+    @Prop({ type: Object })
+    title: Record<string, string>;
+
+    @Prop({ type: Object })
+    subtitle: Record<string, string>;
+
+    @Prop()
+    tableSize: number;
+
+    @Prop()
+    bet: number;
+
+    @Prop()
+    ticketPrice: number;
+
+    @Prop()
+    roomType: string;
+
+    @Prop()
+    gameType: string;
+
+    @Prop()
+    rulesType: string;
+
+    @Prop()
+    deckType?: string;
+}
+
+export const SimpleRoomSchema = SchemaFactory.createForClass(SimpleRoom);

package/src/schemas/tournament_many_tables_rooms.schema.ts

@@ -0,0 +1,70 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type TournamentManyTablesRoomDocument = HydratedDocument<TournamentManyTablesRoom>;
+
+export interface IParticipant {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+}
+
+@Schema({ collection: 'tournament_many_tables_rooms' })
+export class TournamentManyTablesRoom {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly roomId: string;
+
+    @Prop({ type: Object })
+    title: Record<string, string>;
+
+    @Prop({ type: Object })
+    subtitle: Record<string, string>;
+
+    @Prop()
+    tableSize: number;
+
+    @Prop()
+    bet: number;
+
+    @Prop()
+    ticketPrice: number;
+
+    @Prop()
+    roomType: string;
+
+    @Prop()
+    gameType: string;
+
+    @Prop()
+    rulesType: string;
+
+    @Prop()
+    deckType?: string;
+
+    @Prop()
+    createDate: Date;
+
+    @Prop()
+    startDate: Date;
+
+    @Prop({ type: Object })
+    description: Record<string, string>;
+
+    @Prop()
+    participants: Array<IParticipant>;
+
+    @Prop()
+    maxParticipants: number;
+
+    @Prop()
+    status: string;
+
+    @Prop()
+    type: string;
+}
+
+export const TournamentManyTablesRoomSchema = SchemaFactory.createForClass(TournamentManyTablesRoom);

package/src/schemas/tournament_one_table_rooms.schema.ts

@@ -0,0 +1,43 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type TournamentOneTableRoomDocument = HydratedDocument<TournamentOneTableRoom>;
+
+@Schema({ collection: 'tournament_one_table_rooms' })
+export class TournamentOneTableRoom {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly roomId: string;
+
+    @Prop({ type: Object })
+    title: Record<string, string>;
+
+    @Prop({ type: Object })
+    subtitle: Record<string, string>;
+
+    @Prop()
+    tableSize: number;
+
+    @Prop()
+    bet: number;
+
+    @Prop()
+    ticketPrice: number;
+
+    @Prop()
+    roomType: string;
+
+    @Prop()
+    gameType: string;
+
+    @Prop()
+    rulesType: string;
+
+    @Prop()
+    deckType?: string;
+}
+
+export const TournamentOneTableRoomSchema = SchemaFactory.createForClass(TournamentOneTableRoom);

package/src/schemas/tournament_result.schema.ts

@@ -0,0 +1,36 @@
+import { Prop, Schema, SchemaFactory, Virtual } from '@nestjs/mongoose';
+import { Document, HydratedDocument } from 'mongoose';
+
+export type TournamentResultDocument = HydratedDocument<TournamentResult>;
+
+export interface IWinner {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+    profit: number;
+    rank: number;
+}
+
+@Schema({ collection: 'tournament_results' })
+export class TournamentResult {
+    @Virtual({
+        get: function (this: Document) {
+            return this._id.toString();
+        },
+    })
+    readonly resultId: string;
+
+    @Prop()
+    tournamentId: String;
+
+    @Prop()
+    gameType: String;
+
+    @Prop()
+    winners: Array<IWinner>;
+
+    @Prop()
+    createDate: Date;
+}
+
+export const TournamentResultSchema = SchemaFactory.createForClass(TournamentResult);