telegram.service.ts

import { Injectable } from '@nestjs/common';
import { Message, Metadata } from 'node-telegram-bot-api';
import * as TelegramBot from 'node-telegram-bot-api';
import { PrismaService } from '../prisma/prisma.service';
import * as fs from 'fs';
import * as path from 'path';
import { v4 as uuid } from 'uuid';

@Injectable()
export class TelegramService {
    private telegram: TelegramBot;

    constructor(private prismaService: PrismaService) {
        this.telegram = new TelegramBot(process.env.BOT_TOKEN, {
            polling: true,
        });

        this.telegram.onText(/^\/register (.+)/, this.register.bind(this));
        this.telegram.onText(/^\/unregister/, this.unregister.bind(this));
        this.telegram.onText(/^\/state/, this.state.bind(this));
        this.telegram.onText(/^\/start/, this.start.bind(this));
        this.telegram.onText(/^\/commit (.+)/, this.commit.bind(this));
        this.telegram.on('message', this.supplyValue.bind(this));
    }

    private lower = parseInt('aaaaaaa', 36);
    private upper = parseInt('zzzzzzzz', 36);

    private generateSlug() {
        return Math.floor(
            Math.random() * (this.upper - this.lower) + this.lower,
        ).toString(36);
    }

    async start(msg: Message, match: RegExpMatchArray) {
        await this.telegram.sendMessage(
            msg.chat.id,
            `/register [Name]\n/state\n/unregister`,
        );
    }

    async commit(msg: Message, match: RegExpMatchArray) {
        if (!match[1])
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'No message',
            ));

        if (!(await this.isRegistered(msg.from.id)))
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Not registered',
            ));

        const agent = await this.prismaService.agent.findFirst({
            where: { uid: String(msg.from.id) },
        });

        await this.prismaService.entry.create({
            data: {
                agentId: agent.id,
                content: match[1],
            },
        });

        await this.telegram.sendMessage(msg.chat.id, 'Commit accepted');
    }

    async register(msg: Message, match: RegExpMatchArray) {
        if (!match[1])
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Invalid name format',
            ));

        if (await this.isRegistered(msg.from.id))
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Already registered',
            ));

        const agent = await this.prismaService.agent.create({
            data: {
                uid: String(msg.from.id),
                name: match[1],
                slug: this.generateSlug(),
            },
        });

        await this.telegram.sendMessage(
            msg.chat.id,
            `Id: ${agent.id}\nName: ${agent.name}\nCode: ${agent.slug}`,
        );
    }

    async unregister(msg: Message, match: RegExpMatchArray) {
        if (!(await this.isRegistered(msg.from.id)))
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Not registered!',
            ));

        const agent = await this.prismaService.agent.findFirst({
            where: { uid: String(msg.from.id) },
        });

        await this.prismaService.entry.deleteMany({
            where: { agentId: agent.id },
        });

        await this.prismaService.unlockEntry.deleteMany({
            where: { agentId: agent.id },
        });

        await this.prismaService.agent.delete({
            where: { id: agent.id },
        });

        await this.telegram.sendMessage(
            msg.chat.id,
            'Successfully deleted all Entries',
        );
    }

    async state(msg: Message, match: RegExpMatchArray) {
        if (!(await this.isRegistered(msg.from.id)))
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Not registered!',
            ));

        const agent = await this.prismaService.agent.findFirst({
            where: { uid: String(msg.from.id) },
        });

        const entries = await this.prismaService.entry.count({
            where: { agentId: agent.id },
        });

        const unlockEntries = await this.prismaService.unlockEntry.count({
            where: { agentId: agent.id },
        });

        await this.telegram.sendMessage(
            msg.chat.id,
            `Id: ${agent.id}\nName: ${agent.name}\nCode: ${agent.slug}\nPublic Entries: ${entries}\nUnlockable Entries: ${unlockEntries}`,
        );
    }

    async supplyValue(msg: Message, metadata: Metadata) {
        if (metadata.type === 'text' && msg.text.startsWith('/')) return;

        if (!(await this.isRegistered(msg.from.id))) return;

        const agent = await this.prismaService.agent.findFirst({
            where: { uid: String(msg.from.id) },
        });

        if (metadata.type === 'photo') {
            let file,
                size = -1;
            for (const p of msg.photo) {
                if (p.width > size) {
                    size = p.width;
                    file = p.file_id;
                }
            }

            const id = uuid();

            const dest = fs.createWriteStream(
                path.join(process.cwd(), 'static', 'photos', `${id}.jpg`),
            );
            const pipe = this.telegram.getFileStream(file).pipe(dest);

            await new Promise((resolve) => pipe.on('finish', resolve));

            await this.prismaService.unlockEntry.create({
                data: {
                    type: 'picture',
                    agentId: agent.id,
                    path: `${id}.jpg`,
                },
            });

            return void (await this.telegram.sendMessage(
                msg.chat.id,
                `Accepted Photo`,
            ));
        } else if (metadata.type === 'text') {
            await this.prismaService.unlockEntry.create({
                data: {
                    type: 'text',
                    agentId: agent.id,
                    content: msg.text,
                },
            });

            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Accepted Text',
            ));
        } else if (metadata.type === 'location') {
            await this.prismaService.unlockEntry.create({
                data: {
                    agentId: agent.id,
                    type: 'location',
                    lat: msg.location.latitude.toString(),
                    lon: msg.location.longitude.toString(),
                },
            });

            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Accepted Location',
            ));
        } else {
            return void (await this.telegram.sendMessage(
                msg.chat.id,
                'Unsupported DataType',
            ));
        }
    }

    private async isRegistered(uid: string | number): Promise<boolean> {
        return (
            (await this.prismaService.agent.count({
                where: { uid: String(uid) },
            })) > 0
        );
    }
}