fairnesscoop / permacoop

import { CommandHandler } from '@nestjs/cqrs';

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

import { ICustomerRepository } from 'src/Domain/Customer/Repository/ICustomerRepository';

import { GenerateInvoiceCommand } from './GenerateInvoiceCommand';

import { CustomerNotFoundException } from 'src/Domain/Customer/Exception/CustomerNotFoundException';

import { IEventRepository } from 'src/Domain/FairCalendar/Repository/IEventRepository';

import { Invoice } from 'src/Domain/Accounting/Invoice.entity';

import { InvoiceItem } from 'src/Domain/Accounting/InvoiceItem.entity';

import { IInvoiceRepository } from 'src/Domain/Accounting/Repository/IInvoiceRepository';

import { IInvoiceItemRepository } from 'src/Domain/Accounting/Repository/IInvoiceItemRepository';

import { InvoiceIdGenerator } from 'src/Domain/Accounting/Generators/InvoiceIdGenerator';

import { NoBillableEventsFoundException } from 'src/Domain/Accounting/Exception/NoBillableEventsFoundException';

import { IDateUtils } from 'src/Application/IDateUtils';

@CommandHandler(GenerateInvoiceCommand)

export class GenerateInvoiceCommandHandler {

  constructor(

    @Inject('ICustomerRepository')

    private readonly customerRepository: ICustomerRepository,

    @Inject('IEventRepository')

    private readonly eventRepository: IEventRepository,

    @Inject('IInvoiceRepository')

    private readonly invoiceRepository: IInvoiceRepository,

    @Inject('IInvoiceItemRepository')

    private readonly invoiceItemRepository: IInvoiceItemRepository,

    @Inject('IDateUtils')

    private readonly dateUtils: IDateUtils,

    private readonly invoiceIdGenerator: InvoiceIdGenerator

  ) {}

  public async execute(command: GenerateInvoiceCommand): Promise<string> {

    const { customerId, status, generatedDate, user, expireInDays } = command;

    const customer = await this.customerRepository.findOneById(customerId);

    if (!customer) {

      throw new CustomerNotFoundException();

    }

    const [ invoiceId, events ] = await Promise.all([

      this.invoiceIdGenerator.generate(),

      this.eventRepository.findBillableEventsByMonthAndCustomer(generatedDate, customer)

    ]);

    if (!events) {

      throw new NoBillableEventsFoundException();

    }

    const expiryDate = this.dateUtils.addDaysToDate(generatedDate, expireInDays);

    const invoice = new Invoice(invoiceId, status, expiryDate.toISOString(), user, customer);

    const invoiceItems: InvoiceItem[] = [];

    for (const {

      time,

      billable,

      day_duration,

      project_name,

      task_name,

      first_name,

      last_name,

      amount

    } of events) {

      invoiceItems.push(

        new InvoiceItem(

          invoice,

          `${project_name} - ${task_name} - ${first_name} ${last_name}`,

          Math.ceil(time / day_duration * 100) / 100,

          Number(amount),

          billable ? 0 : 100

        )

      );

    }

    await this.invoiceRepository.save(invoice);

    await this.invoiceItemRepository.save(invoiceItems);

    return invoice.getId();

  }

}