fairnesscoop / permacoop

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

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

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

import { GenerateBillingCommand } from './GenerateBillingCommand';

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

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

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

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

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

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

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

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

@CommandHandler(GenerateBillingCommand)

export class GenerateBillingCommandHandler {

  constructor(

    @Inject('ICustomerRepository')

    private readonly customerRepository: ICustomerRepository,

    @Inject('IEventRepository')

    private readonly eventRepository: IEventRepository,

    @Inject('IBillingRepository')

    private readonly billingRepository: IBillingRepository,

    @Inject('IBillingItemRepository')

    private readonly billingItemRepository: IBillingItemRepository,

    private readonly billingIdGenerator: BillingIdGenerator

  ) {}

  public async execute(command: GenerateBillingCommand): 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 billing = new Billing(billingId, status, '', user, customer);

    const billingItems: BillingItem[] = [];

    for (const {

      time,

      billable,

      day_duration,

      project_name,

      task_name,

      first_name,

      last_name,

      amount

    } of events) {

      billingItems.push(

        new BillingItem(

          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();

  }

}