jp.ms.common.modules 1.0.18 → 1.0.21

package/src/modules/main/main.service.ts

@@ -0,0 +1,95 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import { AppScreenRoutesEnum, BaseAppScreen, router } from 'jp.common.models';
+import * as dayjs from 'dayjs';
+import * as isToday from 'dayjs/plugin/isToday';
+import { ActivityLogRepository, UsersRepository } from 'jp.db.schemas';
+
+import { BaseAppScreenDto, PlayerCheckStateDto } from '../../dto';
+import { SimpleRoomsManagerService } from '../simple-rooms-manager';
+import { PlayersManagerService } from '../players-manager';
+import { TournamentOneTableRoomsManagerService } from '../tournament-one-table-rooms-manager';
+import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
+import { EventsBusMainTablesSubscribeService } from '../event-bus/events-bus.main-tables.subscribe.service';
+
+import { MainFactoryOptions } from './main.interfaces';
+import { MAIN_OPTIONS } from './main.constants';
+import { MainTablesListScreenView } from './main-tables-list-screen.view';
+
+@Injectable()
+export class MainService {
+
+    constructor(
+        private readonly simpleRoomsManager: SimpleRoomsManagerService,
+        private readonly oneTableRoomsManagerService: TournamentOneTableRoomsManagerService,
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        private readonly eventsBusMainTablesSubscribeService: EventsBusMainTablesSubscribeService,
+        private readonly userRepository: UsersRepository,
+        private readonly activityLogRepository: ActivityLogRepository,
+        @Inject(MAIN_OPTIONS) private readonly options: MainFactoryOptions,
+    ) {
+        dayjs.extend(isToday);
+    }
+
+    getScreen(lang: string): BaseAppScreenDto {
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new MainTablesListScreenView(
+                    this.options.i18n,
+                    lang,
+                    this.simpleRoomsManager.getRooms(),
+                    this.oneTableRoomsManagerService.getRooms(),
+                    this.manyTablesRoomsManagerService.getRooms(),
+                ).build(),
+            )
+        );
+    }
+
+    subscribeOnTablesScreen(clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+
+        if (player) {
+            this.eventsBusMainTablesSubscribeService.addTablesSubscriber(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    unsubscribeFromTablesScreen(clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+
+        if (player) {
+            this.eventsBusMainTablesSubscribeService.removeTablesSubbcriber(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async playerCheckState(clientAuthToken: string, game: string): Promise<PlayerCheckStateDto> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        let redirectUrl: string = AppScreenRoutesEnum.MENU;
+
+        const foundUser = await this.userRepository.findById(clientAuthToken);
+        const isNewbie = await this.activityLogRepository.userIsNewbie(clientAuthToken)
+        const last7logins = await this.activityLogRepository.findLast7DaysLogins(game, clientAuthToken);
+
+        if (!foundUser) {
+            throw new InternalServerErrorException();
+        }
+
+        if (player?.isPlayer() && player.tableId) {
+            redirectUrl = router.getRoomPath(player.tableId);
+        } else if (isNewbie) {
+            redirectUrl = AppScreenRoutesEnum.WELCOME;
+        } else if (dayjs(last7logins[0].date).isToday() && last7logins[0].count === 1) {
+            redirectUrl = AppScreenRoutesEnum.TODAY_BONUS;
+        } else if (dayjs(foundUser.premiumExpired).isToday()) {
+            redirectUrl = AppScreenRoutesEnum.PREMIUM;
+        }
+
+        return PlayerCheckStateDto.fromEntities(redirectUrl, player?.id ?? '');
+    }
+
+    findFreeTable(clientAuthToken: string) {
+    }
+}

package/src/modules/many-tables-tournament/index.ts

@@ -0,0 +1 @@
+export { ManyTablesTournamentModule } from './many-tables-tournament.module';

package/src/modules/many-tables-tournament/many-tables-tournament-status-screen.view.ts

@@ -0,0 +1,59 @@
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionButtons,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+} from "jp.common.models";
+import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
+
+export class ManyTablesTournamentStatusScreenView extends UniversalScreenView {
+    private readonly tournament: ManyTablesTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: ManyTablesTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return AppScreen.CreateStatusScreen(AppScreenIdEnum.ROOMS)
+            .addAppBar(
+                AppScreenAppBar.CreateStatusAppBar(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection((
+                AppScreenSection.CreateStatusHeader(
+                    'status',
+                    'description',
+                    AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                    AppScreenSectionButtons.CreatePrimaryButtonSection(AppScreenSectionButton.CreateTextButton('button')),
+                )
+            ))
+            .addSection(
+                AppScreenSection.CreateCardListSection(
+                    'id1',
+                    this.tournament.getParticipants().map((item) => AppScreenSectionListItem.CreateCardListItemMini(
+                        item.playerId,
+                        item.playerName,
+                        '',
+                        AppScreenSectionImage.CreateUrlImage(item.playerAvatarUrl),
+                        true,
+                        '',
+                    ))
+                ),
+            );
+    }
+}

package/src/modules/many-tables-tournament/many-tables-tournament-tables-list-screen.view.ts

@@ -0,0 +1,53 @@
+import {
+    AppScreen,
+    AppScreenAppBar,
+    AppScreenIconEnum,
+    AppScreenIdEnum,
+    AppScreenSection,
+    AppScreenSectionButton,
+    AppScreenSectionImage,
+    AppScreenSectionListItem,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    router,
+} from "jp.common.models";
+import { ManyTablesTournamentRoom } from "jp.ms.common.engine";
+
+export class ManyTablesTournamentTablesListScreenView extends UniversalScreenView {
+    private readonly tournament: ManyTablesTournamentRoom;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        tournament: ManyTablesTournamentRoom,
+    ) {
+        super(localeService, lang);
+        this.tournament = tournament;
+    }
+
+    build(): IAppScreen {
+        return AppScreen.CreateStandardScreen(AppScreenIdEnum.ROOMS)
+            .addAppBar(
+                AppScreenAppBar.CreateStandardAppBar(
+                    this.localeService.t('common.rooms.screen.title', { lang: this.lang }),
+                    AppScreenSectionButton.CreateArrowBackButton(this.localeService.t('common.button.back', { lang: this.lang })),
+                ),
+            )
+            .addSection(
+                AppScreenSection.CreateCardListSection(
+                    'id1',
+                    this.tournament?.getTables().map((table) =>
+                        AppScreenSectionListItem.CreateCardListItemMini(
+                            table.getId(),
+                            table.getTitle(this.lang),
+                            table.getSubtitle(this.lang),
+                            AppScreenSectionImage.CreateIconImage(AppScreenIconEnum.EMOJI_EVENTS),
+                            true,
+                            router.getRoomPath(table.getId()),
+                        )
+                    ) ?? []
+                ),
+            );
+    }
+}

package/src/modules/many-tables-tournament/many-tables-tournament.constants.ts

@@ -0,0 +1 @@
+export const MANY_TABLES_TOURNAMENT_OPTIONS = Symbol('MANY_TABLES_TOURNAMENT_OPTIONS');

package/src/modules/many-tables-tournament/many-tables-tournament.controller.ts

@@ -0,0 +1,121 @@
+import { Body, Controller, Get, Param, Post, Headers, HttpStatus, HttpCode, Patch, Delete } from '@nestjs/common';
+import { IAppHeaders, IBaseAppScreen, IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+
+import { ManyTablesTournamentService } from './many-tables-tournament.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+
+@Controller('tournament/many_tables')
+export class ManyTablesTournamentController {
+    constructor(
+        private readonly tournamentService: ManyTablesTournamentService,
+    ) {
+    }
+
+    @Get('status/:tournamentId')
+    getStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseAppScreen {
+        return this.tournamentService.getStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('status/subscribe/:tournamentId')
+    subscribeOnStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.subscribeOnStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('status/unsubscribe/:tournamentId')
+    unsubscribeFromStatusScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.unsubscribeFromStatusScreen(tournamentId, headers.client_language);
+    }
+
+    @Get('tables/:tournamentId')
+    getTableListScreen(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<IBaseAppScreen> {
+        return this.tournamentService.getTableListScreen(tournamentId, headers.client_language);
+    }
+
+    @Post('table/watch/:tableId')
+    @HttpCode(HttpStatus.OK)
+    watchTheTable(
+        @Param('tableId') tableId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.tournamentService.watchTheTable(tableId, headers.client_auth_token);
+    }
+
+    @Post('table/move/:tableId')
+    @HttpCode(HttpStatus.OK)
+    moveOnTheTable(
+        @Param('tableId') tableId: string,
+        @Body() baseMoveData: IBaseMoveData,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.tournamentService.moveOnTheTable(tableId, headers.client_auth_token, baseMoveData);
+    }
+
+    @Post('join/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    joinTournament(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): JoinTournamentDto {
+        return this.tournamentService.joinTournament(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('leave/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    leaveTournament(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): IBaseTableGameState {
+        return this.tournamentService.leaveTournament(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('buy_ticket/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    buyTicket(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.buyTicket(tournamentId, headers.client_auth_token);
+    }
+
+    @Post('create')
+    @HttpCode(HttpStatus.OK)
+    createTournament(
+        @Headers() headers: IAppHeaders,
+        @Body() createTournamentDto: ManyTablesTournamentCreateDto,
+    ): Promise<void> {
+        return this.tournamentService.createTournament(createTournamentDto);
+    }
+
+    @Patch('update/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    updateTournament(
+        @Param('tournamentId') tournamentId: string,
+        @Body() updateTournamentDto: ManyTablesTournamentUpdateDto,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.updateTournament(tournamentId, updateTournamentDto);
+    }
+
+    @Delete('remove/:tournamentId')
+    @HttpCode(HttpStatus.OK)
+    removeTournament(
+        @Param('tournamentId') tournamentId: string,
+        @Headers() headers: IAppHeaders,
+    ): Promise<void> {
+        return this.tournamentService.removeTournament(tournamentId);
+    }
+}

package/src/modules/many-tables-tournament/many-tables-tournament.interfaces.ts

@@ -0,0 +1,15 @@
+import { ModuleMetadata } from '@nestjs/common';
+import { I18nService } from 'nestjs-i18n';
+import { Type } from '@nestjs/common/interfaces/type.interface';
+import { DynamicModule } from '@nestjs/common/interfaces/modules/dynamic-module.interface';
+import { ForwardReference } from '@nestjs/common/interfaces/modules/forward-reference.interface';
+
+export interface ManyTablesTournamentModuleOptions extends Pick<ModuleMetadata, 'imports'> {
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    inject?: any[];
+    useFactory?: (...args: any[]) => Promise<any> | any;
+}
+
+export interface ManyTablesTournamentFactoryOptions {
+    i18n: I18nService
+}

package/src/modules/many-tables-tournament/many-tables-tournament.module.ts

@@ -0,0 +1,53 @@
+import { DynamicModule, Module, Provider } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TournamentManyTablesRoom, TournamentManyTablesRoomSchema, TournamentManyTablesRoomsRepository } from 'jp.db.schemas';
+import { GamePlayer, ManyTablesTournamentUpdateStatusWsEvent, RoomUpdateStateEvent } from 'jp.ms.common.engine';
+
+import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager';
+import { EventsBusManyTablesTournamentSubscribeService } from '../event-bus';
+
+import { ManyTablesTournamentController } from './many-tables-tournament.controller';
+import { ManyTablesTournamentService } from './many-tables-tournament.service';
+import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+import { ManyTablesTournamentModuleOptions } from './many-tables-tournament.interfaces';
+
+@Module({
+    imports: [
+        MongooseModule.forFeature([{ name: TournamentManyTablesRoom.name, schema: TournamentManyTablesRoomSchema }]),
+    ],
+    controllers: [ManyTablesTournamentController],
+    providers: [ManyTablesTournamentService, TournamentManyTablesRoomsRepository],
+})
+export class ManyTablesTournamentModule {
+    constructor(
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly eventsBusManyTablesTournamentSubscribeService: EventsBusManyTablesTournamentSubscribeService,
+        private readonly manyTablesTournamentService: ManyTablesTournamentService,
+    ) { }
+
+    static forRootAsync(options: ManyTablesTournamentModuleOptions): DynamicModule {
+        return {
+            module: ManyTablesTournamentModule,
+            imports: options.imports ?? [],
+            providers: [
+                {
+                    provide: MANY_TABLES_TOURNAMENT_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                } as Provider,
+            ],
+        };
+    }
+
+    async onModuleInit() {
+        this.eventsBusManyTablesTournamentSubscribeService.subscribe(this.onHandleStatusRoomChange);
+    }
+
+    private onHandleStatusRoomChange = (event: RoomUpdateStateEvent) => {
+        this.manyTablesRoomsManagerService.getRoomById(event.roomId)?.getStatusScreenWatchers().forEach((subscriber: GamePlayer) => {
+            const screen = this.manyTablesTournamentService.getStatusScreen(event.roomId, subscriber.language);
+            subscriber.sendMessage(new ManyTablesTournamentUpdateStatusWsEvent(screen.screen));
+        });
+    }
+}
+

package/src/modules/many-tables-tournament/many-tables-tournament.service.ts

@@ -0,0 +1,184 @@
+import { Inject, Injectable, InternalServerErrorException } from '@nestjs/common';
+import {
+    BaseAppScreen,
+    IBaseMoveData,
+    IBaseTableGameState,
+    router,
+} from 'jp.common.models';
+
+import { BaseAppScreenDto } from '../../dto';
+import { TournamentManyTablesRoomsManagerService } from '../tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service';
+import { PlayersManagerService } from '../players-manager/players-manager.service';
+import { JoinTournamentDto } from '../../dto/common/join-tournament.dto';
+import { ManyTablesTournamentCreateDto } from '../../dto/common/many-tables-tournament-create.dto';
+import { ManyTablesTournamentUpdateDto } from '../../dto/common/many-tables-tournament-update.dto';
+
+import { ManyTablesTournamentFactoryOptions } from './many-tables-tournament.interfaces';
+import { MANY_TABLES_TOURNAMENT_OPTIONS } from './many-tables-tournament.constants';
+import { ManyTablesTournamentStatusScreenView } from './many-tables-tournament-status-screen.view';
+import { ManyTablesTournamentTablesListScreenView } from './many-tables-tournament-tables-list-screen.view';
+
+@Injectable()
+export class ManyTablesTournamentService {
+    constructor(
+        private readonly manyTablesRoomsManagerService: TournamentManyTablesRoomsManagerService,
+        private readonly playersManager: PlayersManagerService,
+        @Inject(MANY_TABLES_TOURNAMENT_OPTIONS) private readonly options: ManyTablesTournamentFactoryOptions,
+    ) {
+    }
+
+    getStatusScreen(tournamentId: string, lang: string): BaseAppScreenDto {
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new ManyTablesTournamentStatusScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
+    }
+
+    subscribeOnStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.addToStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    unsubscribeFromStatusScreen(tournamentId: string, clientAuthToken: string): Promise<void> {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (player && tournament) {
+            tournament.removeFromStatusScreenWatchers(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async getTableListScreen(tournamentId: string, lang: string): Promise<BaseAppScreenDto> {
+        const tournament = this.manyTablesRoomsManagerService.getRoomById(tournamentId);
+
+        if (!tournament) {
+            throw new InternalServerErrorException();
+        }
+
+        return new BaseAppScreenDto(
+            new BaseAppScreen(
+                new ManyTablesTournamentTablesListScreenView(
+                    this.options.i18n,
+                    lang,
+                    tournament,
+                ).build()
+            )
+        );
+    }
+
+    watchTheTable(tableId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleWatchTheTable(player, tableId);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    moveOnTheTable(tableId: string, clientAuthToken: string, moveDto: IBaseMoveData): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const room = this.manyTablesRoomsManagerService.getRoomByTableId(tableId);
+        const master = room?.getMasterById(tableId);
+
+        if (player && room && master) {
+            room.handleMoveOnTheTable(player, tableId, moveDto);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    joinTournament(tournamentId: string, clientAuthToken: string): JoinTournamentDto {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleJoinTournament(player);
+
+            if (tournament.getTournamentMaster().isInProgress()) {
+                if (player.isPlayer() || player.isTableQueuer()) {
+                    return JoinTournamentDto.fromEntities(
+                        router.getManyTablesTournamentTablePath(player.tableId ?? ''),
+                        player.id,
+                    );
+                } else {
+                    return JoinTournamentDto.fromEntities(
+                        router.getManyTablesTournamentTableListPath(),
+                        player.id,
+                    );
+                }
+            } else {
+                return JoinTournamentDto.fromEntities(
+                    router.getManyTablesTournamentStatusPath(tournament.getId()),
+                    player.id,
+                );
+            }
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    leaveTournament(tournamentId: string, clientAuthToken: string): IBaseTableGameState {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            tournament.handleLeaveTournament(player);
+
+            return master.createGameStateDto(player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async buyTicket(tournamentId: string, clientAuthToken: string) {
+        const player = this.playersManager.getPlayerById(clientAuthToken);
+        const tournament = this.manyTablesRoomsManagerService.getRoomByTableId(tournamentId);
+        const master = tournament?.getMasterById(tournamentId);
+
+        if (player && tournament && master) {
+            return this.manyTablesRoomsManagerService.buyTicket(tournamentId, player);
+        }
+
+        throw new InternalServerErrorException();
+    }
+
+    async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+        return this.manyTablesRoomsManagerService.createTournament(createTournamentDto);
+    }
+
+    async updateTournament(tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
+        return this.manyTablesRoomsManagerService.updateTournament(tournamentId, updateTournamentDto);
+    }
+
+    async removeTournament(tournamentId: string) {
+        return this.manyTablesRoomsManagerService.removeTournament(tournamentId);
+    }
+}

package/src/modules/menu/index.ts

@@ -0,0 +1 @@
+export { MenuModule } from './menu.module';

package/src/modules/menu/menu-screen.view.ts

@@ -0,0 +1,48 @@
+import {
+    AppScreenIdEnum,
+    IAppScreen,
+    UniversalScreenView,
+    ILocaleService,
+    StandardScreenComponent,
+    IconImageComponent,
+    MenuHeaderSectionComponent,
+    MenuListSectionComponent,
+    MenuSectionListItemComponent,
+} from "jp.common.models";
+import { Menu } from "jp.db.schemas";
+
+export class MenuScreenView extends UniversalScreenView {
+    private readonly menuItems: Array<Menu>;
+
+    constructor(
+        localeService: ILocaleService,
+        lang: string,
+        menuItems: Array<Menu>,
+    ) {
+        super(localeService, lang);
+        this.menuItems = menuItems;
+    }
+
+    build(): IAppScreen {
+        return new StandardScreenComponent(AppScreenIdEnum.MENU)
+            .addSection(
+                new MenuHeaderSectionComponent(
+                    'header',
+                    this.localeService.t('common.menu.header.title', { lang: this.lang }),
+                ),
+            )
+            .addSection(
+                new MenuListSectionComponent(
+                    'id1',
+                    this.menuItems.map((item) => (
+                        new MenuSectionListItemComponent(
+                            item.code,
+                            this.lang === 'ru' ? item.title : item.titleEn,
+                            new IconImageComponent(item.icon),
+                            item.url,
+                        )
+                    )
+                ),
+            ));
+    }
+}