import {IMessage} from '../message/i-message';

export class BaseMessage implements IMessage {
    public chatId: number;
    public lang: string;
    public text: string;
    public fullText: string;
    public command: string;

    protected firstName: string;
    protected lastName: string;

    protected replyStatus: string;
    protected replyData: any;

    get name(): string {
        const firstName: string = this.firstName || '';
        const lastName: string = this.lastName || '';

        return `${firstName} ${lastName}`.trim();
    }

    public getReplyStatus(): string {
        return this.replyStatus;
    }

    public getReplyData(): any {
        return this.replyData;
    }

    public setStatus(status: string): IMessage {
        this.replyStatus = status;
        return this;
    }

    public withData(data: any): IMessage {
        this.replyData = data;
        return this;
    }

    public answer(args: any): string | void {
        throw new Error('not implemented');
    }
}
}

import {BaseMessage} from '../message/base.message';
import {IMessage} from '../message/i-message';

export class TelegramMessage extends BaseMessage implements IMessage {
    private ctx: any;

    constructor(ctx) {
        super();

        this.ctx = ctx;

        const {message} = this.ctx.update;
        this.chatId = message.chat.id;
        this.fullText = message.text;
        this.command = this.ctx.command;
        this.text = this.fullText.replace(`/${this.command}`, '');
        this.lang = message.from.language_code;
        this.firstName = message.from.first_name;
        this.lastName = message.from.last_name;
    }

    public answer(args: any): string | void {
        return this.ctx.replyWithHTML(args);
    }
}

import {BaseMessage} from '../message/base.message';
import {IMessage} from '../message/i-message';

export class VKMessage extends BaseMessage implements IMessage {
    private ctx: any;

    constructor(ctx) {
        super();

        this.ctx = ctx;

        const {message} = this.ctx;
        this.chatId = this.getChatId(this.ctx);
        this.fullText = message.text;
        this.command = this.ctx.command;
        this.text = this.fullText.replace(`/${this.command}`, '');
        this.lang = 'ru';
        this.firstName = message.from.first_name;
        this.lastName = message.from.last_name;
    }

    public answer(args: any) {
        const answer: string = `${args}`.replace(/<\/?(strong|i)>/gm, '');
        this.ctx.reply(answer);
    }

    private getChatId({message, bot}): number {
        const peerId: number = +`${message.peer_id}`.replace(/[0-9]0+/, '');
        const groupId: number = bot.settings.group_id;
        return peerId + groupId;
    }
}

import Telegraf from 'telegraf';

import {Injectable} from '@nestjs/common';
import * as SocksAgent from 'socks5-https-client/lib/Agent';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {TelegramMessage} from './telegram.message';

@Injectable()
export class TelegramService {
    private bot: Telegraf<any>;

    constructor(config: ConfigService, appEmitter: AppEmitter) {
        const botToken: string = config.get('TELEGRAM_BOT_TOKEN');

        this.bot = config.get('TELEGRAM_USE_PROXY')
            ? new Telegraf(botToken, {
                  telegram: {agent: this.getProxy(config)},
              })
            : new Telegraf(botToken);

        this.getCommandEventMapping(appEmitter).forEach(([command, event]) => {
            this.bot.command(command, ctx => {
                ctx.command = command;
                appEmitter.emit(event, new TelegramMessage(ctx));
            });
        });
    }

    public launch(): void {
        this.bot.launch();
    }

    private getProxy(config: ConfigService): SocksAgent {
        return new SocksAgent({
            socksHost: config.get('TELEGRAM_PROXY_HOST'),
            socksPort: config.get('TELEGRAM_PROXY_PORT'),
            socksUsername: config.get('TELEGRAM_PROXY_LOGIN'),
            socksPassword: config.get('TELEGRAM_PROXY_PASSWORD'),
        });
    }

    private getCommandEventMapping(
        appEmitter: AppEmitter,
    ): Array<[string, string]> {
        return [
            ['event_add', appEmitter.EVENT_ADD],
            ['event_remove', appEmitter.EVENT_REMOVE],
            ['info', appEmitter.EVENT_INFO],
            ['add', appEmitter.PLAYER_ADD],
            ['remove', appEmitter.PLAYER_REMOVE],
        ];
    }
}

import * as VkBot from 'node-vk-bot-api';

import {Injectable} from '@nestjs/common';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {VKMessage} from './vk.message';

@Injectable()
export class VKService {
    private bot: VkBot<any>;

    constructor(config: ConfigService, appEmitter: AppEmitter) {
        const botToken: string = config.get('VK_TOKEN');

        this.bot = new VkBot(botToken);

        this.getCommandEventMapping(appEmitter).forEach(([command, event]) => {
            this.bot.command(`/${command}`, async ctx => {
                const [from] = await this.bot.execute('users.get', {
                    user_ids: ctx.message.from_id,
                });
                ctx.message.from = from;
                ctx.command = command;
                appEmitter.emit(event, new VKMessage(ctx));
            });
        });
    }

    public launch(): void {
        this.bot.startPolling();
    }

    private getCommandEventMapping(
        appEmitter: AppEmitter,
    ): Array<[string, string]> {
        return [
            ['event_add', appEmitter.EVENT_ADD],
            ['event_remove', appEmitter.EVENT_REMOVE],
            ['info', appEmitter.EVENT_INFO],
            ['add', appEmitter.PLAYER_ADD],
            ['remove', appEmitter.PLAYER_REMOVE],
        ];
    }
}

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    OneToMany,
    JoinColumn,
    Index,
} from 'typeorm';
import {Event} from './event';

@Entity()
export class Chat {
    @PrimaryGeneratedColumn()
    id: number;

    @Index({unique: true})
    @Column()
    chatId: number;

    @OneToMany(type => Event, event => event.chat)
    @JoinColumn()
    events: Event[];
}

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    OneToMany,
    ManyToOne,
    JoinColumn,
} from 'typeorm';
import {Chat} from './chat';
import {Player} from './player';

@Entity()
export class Event {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    date: Date;

    @Column()
    active: boolean;

    @ManyToOne(type => Chat, chat => chat.events)
    chat: Chat;

    @OneToMany(type => Player, player => player.event)
    @JoinColumn()
    players: Player[];
}

import {
    Entity,
    PrimaryGeneratedColumn,
    Column,
    ManyToOne,
    JoinColumn,
} from 'typeorm';
import {Event} from './event';

@Entity()
export class Player {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @ManyToOne(type => Event, event => event.players)
    @JoinColumn()
    event: Event;
}

import {Injectable} from '@nestjs/common';
import {InjectConnection} from '@nestjs/typeorm';
import {Connection, Repository, UpdateResult} from 'typeorm';

import {Chat} from './models/chat';
import {Event} from './models/event';
import {Player} from './models/player';

@Injectable()
export class StorageService {
    private chatRepository: Repository<Chat>;
    private eventRepository: Repository<Event>;
    private playerRepository: Repository<Player>;

    constructor(@InjectConnection() private readonly dbConnection: Connection) {
        this.chatRepository = this.dbConnection.getRepository(Chat);
        this.eventRepository = this.dbConnection.getRepository(Event);
        this.playerRepository = this.dbConnection.getRepository(Player);
    }

    public get connection() {
        return this.dbConnection;
    }

    public async ensureChat(chatId: number): Promise<Chat> {
        let chat: Chat = await this.chatRepository.findOne({chatId});

        if (chat) {
            return chat;
        }

        chat = new Chat();
        chat.chatId = chatId;

        return this.chatRepository.save(chat);
    }

    public markChatEventsInactive(chat: Chat): Promise<UpdateResult> {
        return this.dbConnection
            .createQueryBuilder()
            .update(Event)
            .set({active: false})
            .where({chat})
            .execute();
    }

    public appendChatActiveEvent(chat: Chat, date: Date): Promise<Event> {
        const event: Event = new Event();
        event.chat = chat;
        event.active = true;
        event.date = date;

        return this.eventRepository.save(event);
    }

    public findChatActiveEvent(chat: Chat): Promise<Event | null> {
        return this.eventRepository.findOne({where: {chat, active: true}});
    }

   public getPlayers(event: Event): Promise<Player[]> {
        return this.playerRepository.find({where: {event}});
    }

    public findPlayer(event: Event, name: string): Promise<Player | null> {
        return this.playerRepository.findOne({where: {event, name}});
    }

    public addPlayer(event: Event, name: string): Promise<Player> {
        const player: Player = new Player();
        player.event = event;
        player.name = name;

        return this.playerRepository.save(player);
    }

    public removePlayer(player: Player): Promise<Player> {
        return this.playerRepository.remove(player);
    }
}

import * as path from 'path';
import * as fs from 'fs';
import * as handlebars from 'handlebars';
import {readDirDeepSync} from 'read-dir-deep';
import {Injectable, Logger} from '@nestjs/common';

export interface IParams {
    action: string;
    status: string;
    lang?: string;
}

@Injectable()
export class TemplateService {
    private readonly DEFAULT_LANG: string = 'en';
    private readonly TEMPLATE_PATH: string = 'templates';

    private logger: Logger;
    private templatesMap: Map<string, (d: any) => string>;

    constructor(logger: Logger) {
        this.logger = logger;

        this.load();
    }

    public apply(params: IParams, data: any): string {
        this.logger.log(
            `apply template: ${params.action} ${params.status} ${params.lang}`,
        );

        let template = this.getTemplate(params);

        if (!template) {
            params.lang = this.DEFAULT_LANG;
            template = this.getTemplate(params);
        }

        if (!template) {
            throw new Error('template-not-found');
        }

        return template(data);
    }

    private getTemplate(params: IParams): (data: any) => string {
        const {lang, action, status} = params;
        return this.templatesMap.get(this.getTemplateKey(lang, action, status));
    }

    private load() {
        const templatesDir: string = path.join(
            process.cwd(),
            this.TEMPLATE_PATH,
        );
        const templateFileNames: string[] = readDirDeepSync(templatesDir);

        this.templatesMap = templateFileNames.reduce((acc, fileName) => {
            const template = fs.readFileSync(fileName, {encoding: 'utf-8'});

            const [, lang, action, status] = fileName
                .replace(/\.hbs$/, '')
                .split('/');
            return acc.set(
                this.getTemplateKey(lang, action, status),
                handlebars.compile(template),
            );
        }, new Map());
    }

    private getTemplateKey(
        lang: string,
        action: string,
        status: string,
    ): string {
        return `${lang}-${action}-${status}`;
    }
}

import {Injectable, Logger} from '@nestjs/common';
import {IMessage} from '../message/i-message';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {TemplateService} from '../common/template.service';
import {StorageService} from '../storage/storage.service';
import {Chat} from '../storage/models/chat';

@Injectable()
export class BaseAction {
    protected appEmitter: AppEmitter;
    protected config: ConfigService;
    protected logger: Logger;

    protected templateService: TemplateService;
    protected storageService: StorageService;

    protected event: string;

    constructor(
        config: ConfigService,
        appEmitter: AppEmitter,
        logger: Logger,
        templateService: TemplateService,
        storageService: StorageService,
    ) {
        this.config = config;
        this.logger = logger;

        this.appEmitter = appEmitter;
        this.templateService = templateService;
        this.storageService = storageService;

        this.setEvent();

        this.logger.log(`subscribe on "${this.event}" event`);
        this.appEmitter.on(this.event, this.handleEvent.bind(this));
    }

    protected setEvent(): void {
        throw new Error('not implemented');
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        throw new Error('not implemented');
    }

    private async handleEvent(message: IMessage) {
        try {
            this.logger.log(`"${this.event}" event received`);

            const chatId: number = message.chatId;
            const chat: Chat = await this.storageService.ensureChat(chatId);
            message = await this.doAction(chat, message);

            message.answer(
                this.templateService.apply(
                    {
                        action: this.event,
                        status: message.getReplyStatus(),
                        lang: message.lang,
                    },
                    message.getReplyData(),
                ),
            );
        } catch (error) {
            this.logger.error(error);
            message.answer(error.message);
        }
    }
}

import {Injectable} from '@nestjs/common';

import * as statuses from './statuses';
import {parseEventDate, formatEventDate} from '../common/utils';
import {BaseAction} from './base.action';
import {Chat} from '../storage/models/chat';
import {Event} from '../storage/models/event';
import {IMessage} from '../message/i-message';

@Injectable()
export class EventAddAction extends BaseAction {
    protected setEvent(): void {
        this.event = this.appEmitter.EVENT_ADD;
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        await this.storageService.markChatEventsInactive(chat);

        const eventDate: Date = parseEventDate(message.text.trim());

        if (!eventDate) {
            return message.setStatus(statuses.STATUS_INVALID_DATE);
        }

        const event: Event = await this.storageService.appendChatActiveEvent(
            chat,
            eventDate,
        );

        return message.setStatus(statuses.STATUS_SUCCESS).withData({
            date: formatEventDate(event.date),
        });
    }
}

import {Injectable} from '@nestjs/common';

import * as statuses from './statuses';
import {formatEventDate} from '../common/utils';
import {BaseAction} from './base.action';
import {Chat} from '../storage/models/chat';
import {Event} from '../storage/models/event';
import {IMessage} from '../message/i-message';

@Injectable()
export class EventRemoveAction extends BaseAction {
    protected setEvent(): void {
        this.event = this.appEmitter.EVENT_REMOVE;
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        const activeEvent: Event = await this.storageService.findChatActiveEvent(
            chat,
        );
        await this.storageService.markChatEventsInactive(chat);

        if (activeEvent) {
            return message.setStatus(statuses.STATUS_SUCCESS).withData({
                date: formatEventDate(activeEvent.date),
            });
        } else {
            return message.setStatus(statuses.STATUS_NO_EVENT);
        }
    }
}

import {Injectable, Logger} from '@nestjs/common';

import * as statuses from './statuses';
import {formatEventDate} from '../common/utils';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {TemplateService} from '../common/template.service';
import {StorageService} from '../storage/storage.service';
import {BaseAction} from './base.action';
import {PlayerHelper} from './player.helper';
import {Chat} from '../storage/models/chat';
import {Event} from '../storage/models/event';
import {Player} from '../storage/models/player';
import {IMessage} from '../message/i-message';

@Injectable()
export class EventInfoAction extends BaseAction {
    private playerHelper: PlayerHelper;

    constructor(
        config: ConfigService,
        appEmitter: AppEmitter,
        logger: Logger,
        templateService: TemplateService,
        playerHelper: PlayerHelper,
        storageService: StorageService,
    ) {
        super(config, appEmitter, logger, templateService, storageService);

        this.playerHelper = playerHelper;
    }

    protected setEvent(): void {
        this.event = this.appEmitter.EVENT_INFO;
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        const activeEvent: Event = await this.storageService.findChatActiveEvent(
            chat,
        );

        if (!activeEvent) {
            return message.setStatus(statuses.STATUS_NO_EVENT);
        }

        const players: Player[] = await this.storageService.getPlayers(
            activeEvent,
        );

        return message.setStatus(statuses.STATUS_SUCCESS).withData({
            date: formatEventDate(activeEvent.date),
            ...(await this.playerHelper.getPlayersList(activeEvent)),
        });
    }
}

import {Injectable, Logger} from '@nestjs/common';

import * as statuses from './statuses';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {TemplateService} from '../common/template.service';
import {StorageService} from '../storage/storage.service';
import {BaseAction} from './base.action';
import {PlayerHelper} from './player.helper';
import {Chat} from '../storage/models/chat';
import {Event} from '../storage/models/event';
import {Player} from '../storage/models/player';
import {IMessage} from '../message/i-message';

@Injectable()
export class PlayerAddAction extends BaseAction {
    private playerHelper: PlayerHelper;

    constructor(
        config: ConfigService,
        appEmitter: AppEmitter,
        logger: Logger,
        templateService: TemplateService,
        playerHelper: PlayerHelper,
        storageService: StorageService,
    ) {
        super(config, appEmitter, logger, templateService, storageService);

        this.playerHelper = playerHelper;
    }

    protected setEvent(): void {
        this.event = this.appEmitter.PLAYER_ADD;
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        const activeEvent: Event = await this.storageService.findChatActiveEvent(
            chat,
        );

        if (!activeEvent) {
            return message.setStatus(statuses.STATUS_NO_EVENT);
        }

        const name: string = this.playerHelper.getPlayerName(message);
        const existedPlayer: Player = await this.storageService.findPlayer(
            activeEvent,
            name,
        );

        if (existedPlayer) {
            return message
                .setStatus(statuses.STATUS_ALREADY_ADDED)
                .withData({name});
        }

        const newPlayer: Player = await this.storageService.addPlayer(
            activeEvent,
            name,
        );

        return message.setStatus(statuses.STATUS_SUCCESS).withData({
            name: newPlayer.name,
            ...(await this.playerHelper.getPlayersList(activeEvent)),
        });
    }
}

import {Injectable, Logger} from '@nestjs/common';

import * as statuses from './statuses';
import {ConfigService} from '../common/config.service';
import {AppEmitter} from '../common/event-bus.service';
import {TemplateService} from '../common/template.service';
import {StorageService} from '../storage/storage.service';
import {BaseAction} from './base.action';
import {PlayerHelper} from './player.helper';
import {Chat} from '../storage/models/chat';
import {Event} from '../storage/models/event';
import {Player} from '../storage/models/player';
import {IMessage} from '../message/i-message';

@Injectable()
export class PlayerRemoveAction extends BaseAction {
    private playerHelper: PlayerHelper;

    constructor(
        config: ConfigService,
        appEmitter: AppEmitter,
        logger: Logger,
        templateService: TemplateService,
        playerHelper: PlayerHelper,
        storageService: StorageService,
    ) {
        super(config, appEmitter, logger, templateService, storageService);

        this.playerHelper = playerHelper;
    }

    protected setEvent(): void {
        this.event = this.appEmitter.PLAYER_REMOVE;
    }

    protected async doAction(chat: Chat, message: IMessage): Promise<IMessage> {
        const activeEvent: Event = await this.storageService.findChatActiveEvent(
            chat,
        );

        if (!activeEvent) {
            return message.setStatus(statuses.STATUS_NO_EVENT);
        }

        const name: string = this.playerHelper.getPlayerName(message);
        const existedPlayer: Player = await this.storageService.findPlayer(
            activeEvent,
            name,
        );

        if (!existedPlayer) {
            return message
                .setStatus(statuses.STATUS_NO_PLAYER)
                .withData({name});
        }

        await this.storageService.removePlayer(existedPlayer);

        return message.setStatus(statuses.STATUS_SUCCESS).withData({
            name,
            ...(await this.playerHelper.getPlayersList(activeEvent)),
        });
    }
}

import {Injectable} from '@nestjs/common';
import {StorageService} from '../storage/storage.service';
import {Event} from '../storage/models/event';
import {Player} from '../storage/models/player';
import {IMessage} from '../message/i-message';

@Injectable()
export class PlayerHelper {
    protected storageService: StorageService;

    constructor(storageService: StorageService) {
        this.storageService = storageService;
    }

    public getPlayerName(message: IMessage) {
        const name = message.text.trim();
        return name.length > 0 ? name : message.name;
    }

    public async getPlayersList(event: Event) {
        const players: Player[] = await this.storageService.getPlayers(event);

        return {
            total: players.length,
            players: players.map((player, index) => ({
                index: index + 1,
                name: player.name,
            })),
        };
    }
}