Migrating to Webhook about nestjs-telegraf HOT 7 CLOSED

import { NestFactory } from '@nestjs/core';
import { AppModule } from './modules/app/modules/app.module';
import { ValidationPipe } from '@nestjs/common';
import { Swagger } from './modules/utils/swagger';
import { getBotToken } from 'nestjs-telegraf';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, { cors: true });
  app.setGlobalPrefix('/extrata-chatbot');
  app.enableShutdownHooks();
  app.useGlobalPipes(new ValidationPipe({ transform: true }));
  const bot = app.get(getBotToken());
  app.use(bot.webhookCallback('/extrata-chatbot'));

  Swagger.init(app);
  await app.listen(3002);
}
bootstrap();

TelegrafModule.forRootAsync({
      useFactory: async (configService: ConfigService) => ({
        token: configService.get('TELEGRAM_BOT_TOKEN'),
        launchOptions: {
          webhook: {
            hookPath:
              'https://b77e-2804-14c-65e4-8522-1550-2541-7442-7252.sa.ngrok.io/extrata-chatbot',
          },
        },
      }),
      inject: [ConfigService],
    }),

import { On, Start, Update } from 'nestjs-telegraf';
import { Inject, Injectable } from '@nestjs/common';
import { TelegramCacheService } from './telegram-cache.service';
import { StepEnum } from '../enums/step.enum';
import { TelegramUserService } from './telegram-user.service';
import { MessageUtils } from '../utils/message.utils';
import { MessageCodeEnum } from '../enums/message-code.enum';
import { TelegramInstitutionService } from './telegram-institution.service';
import { ConfigService } from '@nestjs/config';
import { TelegramMenuService } from './telegram-menu.service';
import { TelegramOpportunitiesService } from './telegram-opportunities.service';
import { TelegramProceedingService } from './telegram-proceeding.service';
import { TelegramContactUsService } from './telegram-contact-us.service';
import { ActionsUtils } from '../utils/actions.utils';
import { ActionsEnum } from '../enums/actions.enum';

@Update()
@Injectable()
export class TelegramService {
  @Inject(TelegramCacheService)
  private readonly cache: TelegramCacheService;

  @Inject(TelegramUserService)
  private readonly userService: TelegramUserService;

  @Inject(TelegramInstitutionService)
  private readonly institutionService: TelegramInstitutionService;

  @Inject(TelegramMenuService)
  private readonly menuService: TelegramMenuService;

  @Inject(TelegramOpportunitiesService)
  private readonly opportunitiesService: TelegramOpportunitiesService;

  @Inject(TelegramProceedingService)
  private readonly proceedingMenu: TelegramProceedingService;

  @Inject(TelegramContactUsService)
  private readonly contactUsService: TelegramContactUsService;

  @Inject(ConfigService)
  private config: ConfigService;

  private success: boolean;

  @Start()
  async startCommand(ctx) {
    await this.cache.del(ctx.chat.id.toString());
    await ctx.telegram.sendMessage(
      ctx.chat.id,
      'Favor, informar seu CPF para iniciar o atendimento',
      MessageUtils.get(MessageCodeEnum.MENU_HIDE),
    );
  }

  private async completeService(ctx) {
    await ctx.reply(MessageUtils.get(MessageCodeEnum.SERVICE_COMPLETED));
    await this.startCommand(ctx);
  }

  @On('text')
  public async hears(ctx) {
    if (ctx.update.message.text == ActionsUtils.get(ActionsEnum.EXIT)) {
      await this.completeService(ctx);
      return;
    }

    const chatId = ctx.chat.id.toString();

    if (!(await this.cache.exists(chatId))) {
      await this.cache.init(ctx);
    }

    const session = await this.cache.get(chatId);

    switch (session.step) {
      case StepEnum.INITIAL:
        this.success = await this.userService.login(ctx, session);
        if (this.success) {
          session.step = StepEnum.USER_VERIFICATION;
          await this.cache.set(chatId, session);
          await this.userService.requestVerification(ctx);
        }
        break;
      case StepEnum.USER_VERIFICATION:
        await this.userService.requestVerification(ctx, true);
        break;
      case StepEnum.INSTITUTION_REQUEST:
        await this.institutionService.list(ctx, session);
        break;
      case StepEnum.INSTITUTION_PICK:
        this.success = await this.institutionService.pick(ctx, session);
        if (this.success) {
          await this.menuService.show(ctx, session);
        }
        break;
      case StepEnum.MENU_MAIN:
        await this.menuService.show(ctx, session);
        break;
      case StepEnum.MENU_MAIN_PICK:
        await this.menuService.goTo(ctx, session);
        break;
      case StepEnum.OPPORTUNITIES_MENU_PICK:
        await this.opportunitiesService.goTo(ctx, session);
        break;
      case StepEnum.OPPORTUNITIES_REQUEST:
        await this.opportunitiesService.findByCode(ctx, session);
        break;
      case StepEnum.OPPORTUNITIES_GROUP_MENU:
        await this.opportunitiesService.findByGroup(ctx, session);
        break;
      case StepEnum.PROCEEDING_MENU_PICK:
        await this.proceedingMenu.goTo(ctx, session);
        break;
      case StepEnum.PROCEEDING_ACTIVATE:
        await this.proceedingMenu.activateMonitoring(ctx, session);
        break;
      case StepEnum.PROCEEDING_REQUEST:
        await this.proceedingMenu.findByNumber(ctx, session);
        break;
      case StepEnum.MENU_CONTACT_US:
        await this.contactUsService.goTo(ctx, session);
        break;
      case StepEnum.PROPOSAL_SHOW:
        await this.proceedingMenu.proposalShow(ctx, session);
        break;
      case StepEnum.PROCEEDING_MONITORED:
        await this.proceedingMenu.monitoredShow(ctx, session);
        break;
      case StepEnum.REQUEST_BUG:
        await this.contactUsService.reportBug(ctx, session);
        break;
      case StepEnum.REQUEST_SUGGESTION:
        await this.contactUsService.sendSuggestion(ctx, session);
        break;
    }
  }

  @On('contact')
  public async validateUser(ctx) {
    const chatId = ctx.chat.id.toString();
    const session = await this.cache.get(chatId);

    switch (session.step) {
      case StepEnum.USER_VERIFICATION:
        if (await this.userService.validate(ctx)) {
          await this.userService.linkTelegram(ctx);
          await ctx.telegram.sendMessage(
            chatId,
            MessageUtils.get(MessageCodeEnum.WELCOME, session.user.name),
          );
          await this.institutionService.list(ctx, session);
        } else {
          await this.completeService(ctx);
        }
        break;
    }
  }
}