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 billingRepository: IInvoiceRepository,

    @Inject('IInvoiceItemRepository')

    private readonly billingItemRepository: IInvoiceItemRepository,

    @Inject('IDateUtils')

    private readonly dateUtils: IDateUtils,

    private readonly billingIdGenerator: InvoiceIdGenerator

  ) {}

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

    const { customerId, status, date, user } = command;

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

    if (!customer) {

      throw new CustomerNotFoundException();

    }

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

      this.billingIdGenerator.generate(),

      this.eventRepository.findBillableEventsByMonthAndCustomer(date, customer)

    ]);

    if (!events) {

      throw new NoBillableEventsFoundException();

    }

    const date = this.dateUtils.getCurrentDate();

    //const expiryDate = new Date(Date.now() + days * 24*60*60*1000);

    const billing = new Invoice(billingId, status, '', user, customer);

    const billingItems: InvoiceItem[] = [];

    for (const {

      time,

      billable,

      day_duration,

      project_name,

      task_name,

      first_name,

      last_name,

      amount

    } of events) {

      billingItems.push(

        new InvoiceItem(

          billing,

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

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

          Number(amount),

          billable ? 0 : 100

        )

      );

    }

    await this.billingRepository.save(billing);

    await this.billingItemRepository.save(billingItems);

    return billing.getId();

  }

}