Chamo na negociação o service do boleto, dando tudo certo atualizo a parcela da negociação (modules -> negociacoes -> services

negociacao-boleto-change-duedate.service.ts

import {
  Injectable,
  Logger,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import * as moment from 'moment-timezone';
import { getManager } from 'typeorm';

import { HistoricoCategoriaType } from '@/common/types/historico.types';
import { dateTimeNow, dateWithoutTime } from '@/common/util';
import { BoletoChangeDuedateService } from '@/modules/boleto/services/boleto-change-duedate.service';
import { BoletoStatusType } from '@/modules/boleto/types/boleto.types';
import {
  ModelProvider,
  NegociacaoParcela,
  TituloHistoricoCobranca,
  User,
} from '@/modules/database/providers/model.provider';

import { AlteraVencimentoParcelaNegociacaoInput } from '../dto/altera-vencimento-parcela-negociacao.input';

/**
 * @class NegociacaoBoletoChangeDuedateService
 * @description Altera a data de vencimento do boleto e da parcela da negociação
 */

@Injectable()
export class NegociacaoBoletoChangeDuedateService {
  private readonly logger = new Logger(NegociacaoBoletoChangeDuedateService.name);
  private dataInput: AlteraVencimentoParcelaNegociacaoInput = null;

  constructor(
    private readonly models: ModelProvider,
    private readonly boletoChangeDuedateService: BoletoChangeDuedateService,
  ) {}

  /**
   * @function call
   * @description Altera a data de vencimento do boleto e da parcela da negociação
   * @param {AlteraVencimentoBoletoNegociacaoInput} data: Campos
   * @param {User} user: Usuário logado
   * @returns {boolean}
   */
  async call(user: User, data: AlteraVencimentoParcelaNegociacaoInput): Promise<boolean> {
    this.logger.log('Alterando o vencimento da parcela da negociação...');

    this.dataInput = data;
    const parcela = await this.fetchParcela(data.parcelaId);

    // Valida a nova data de vencimento
    const vencimento = dateWithoutTime(data.dataVencimento);
    const hoje = dateWithoutTime();

    if (vencimento < hoje)
      throw new UnprocessableEntityException(`Vencimento informado é menor que a data atual.`);

    // Atualiza a data na FITBANK
    const response = await this.boletoChangeDuedateService.call(
      parcela.boletoId,
      data.dataVencimento,
    );

    if (!response.success) {
      throw new NotFoundException(`Não foi possível alterar o vencimento: ${response.message}`);
    }

    return this.update(user, parcela);
  }

  /**
   * @private
   * @function fetchParcela
   * @description Busca uma parcela da negociação
   * @param {number} parcelaId: ID da parcela
   * @returns {NegociacaoParcela}
   */
  private async fetchParcela(parcelaId: number): Promise<NegociacaoParcela> {
    const parcela = await this.models.NegociacaoParcela.createQueryBuilder('parcela')
      .innerJoinAndSelect('parcela.negociacao', 'negociacao')
      .innerJoinAndSelect('parcela.boleto', 'boleto')
      .where('parcela.id = :id', { id: parcelaId })
      .andWhere('parcela.boletoGerado IS TRUE')
      .andWhere('boleto.status = :status', { status: BoletoStatusType.REGISTRADO })
      .getOne();

    if (!parcela) throw new NotFoundException(`Parcela com ID "${parcelaId}" não encontrado.`);

    return parcela;
  }

  /**
   * @private
   * @function update
   * @description Atualiza a parcela da negociação no banco
   * @param {User} user: Usuário logado
   * @param {NegociacaoParcela} parcela: Parcela da negociação
   * @returns boolean
   */
  private async update(user: User, parcela: NegociacaoParcela): Promise<boolean> {
    const { HistoricoCobranca } = this.models;

    const tipoHistorico = await this.fetchTipoHistorico();

    return getManager().transaction(async (manager) => {
      const parcelaVencimentoOriginal = moment(parcela.vencimento).format('DD/MM/YYYY');
      const parcelaVencimentoNovo = moment(this.dataInput.dataVencimento).format('DD/MM/YYYY');
      const textoHistorico = `Negociação: ${parcela.negociacaoId}. Parcela de número ${parcela.numero} com o vencimento ${parcelaVencimentoOriginal} alterado para ${parcelaVencimentoNovo}`;

      parcela.vencimentoOriginal = parcela.vencimento;
      parcela.vencimento = new Date(this.dataInput.dataVencimento);
      parcela.updatedAt = dateTimeNow();

      await manager.save(parcela);

      // Cria o histórico
      const historico = HistoricoCobranca.create({
        descricao: textoHistorico,
        interno: false,
        tipo: tipoHistorico.sigla,
        tituloHistoricoCobrancaId: tipoHistorico.id,
        ativo: 'S',
        categoria: HistoricoCategoriaType.AUTOMATICO,
        userId: user.id,
        clienteId: parcela.negociacao.clienteId,
        model: 'negociacoes',
        modelId: parcela.negociacaoId,
        extra: {
          negociacaoParcelaId: parcela.id,
        },
      });

      await manager.save(historico);

      return true;
    });
  }

  /**
   * @private
   * @function fetchTipoHistorico
   * @description Busca um título do histórico de cobrança
   * @returns {TituloHistoricoCobranca}
   */
  private async fetchTipoHistorico(): Promise<TituloHistoricoCobranca> {
    return this.models.TituloHistoricoCobranca.findOne({
      where: { sigla: 'NE' },
      select: ['id', 'sigla'],
    });
  }
}