Uecko_ERP/modules/customer-invoices/src/api/infrastructure/mappers/customer-invoice.mapper.ts

import { ISequelizeMapper, MapperParamsType, SequelizeMapper } from "@erp/core/api";
import { UniqueID, UtcDate } from "@repo/rdx-ddd";
import { Result } from "@repo/rdx-utils";
import {
  CustomerInvoice,
  CustomerInvoiceNumber,
  CustomerInvoiceSerie,
  CustomerInvoiceStatus,
} from "../../domain";
import { CustomerInvoiceCreationAttributes, CustomerInvoiceModel } from "../sequelize";
import { CustomerInvoiceItemMapper } from "./customer-invoice-item.mapper";

export interface ICustomerInvoiceMapper
  extends ISequelizeMapper<
    CustomerInvoiceModel,
    CustomerInvoiceCreationAttributes,
    CustomerInvoice
  > {}

export class CustomerInvoiceMapper
  extends SequelizeMapper<CustomerInvoiceModel, CustomerInvoiceCreationAttributes, CustomerInvoice>
  implements ICustomerInvoiceMapper
{
  private customerInvoiceItemMapper: CustomerInvoiceItemMapper;

  constructor() {
    super();
    this.customerInvoiceItemMapper = new CustomerInvoiceItemMapper(); // Instanciar el mapper de items
  }

  public mapToDomain(
    source: CustomerInvoiceModel,
    params?: MapperParamsType
  ): Result<CustomerInvoice, Error> {
    const idOrError = UniqueID.create(source.id);
    const statusOrError = CustomerInvoiceStatus.create(source.invoice_status);
    const customerInvoiceSeriesOrError = CustomerInvoiceSerie.create(source.invoice_series);
    const customerInvoiceNumberOrError = CustomerInvoiceNumber.create(source.invoice_number);
    const issueDateOrError = UtcDate.createFromISO(source.issue_date);
    const operationDateOrError = UtcDate.createFromISO(source.operation_date);

    const result = Result.combine([
      idOrError,
      statusOrError,
      customerInvoiceSeriesOrError,
      customerInvoiceNumberOrError,
      issueDateOrError,
      operationDateOrError,
    ]);

    if (result.isFailure) {
      return Result.fail(result.error);
    }

    // Mapear los items de la factura
    const itemsOrErrors = this.customerInvoiceItemMapper.mapArrayToDomain(source.items, {
      sourceParent: source,
      ...params,
    });

    if (itemsOrErrors.isFailure) {
      return Result.fail(itemsOrErrors.error);
    }

    const customerInvoiceCurrency = source.invoice_currency || "EUR";

    return CustomerInvoice.create(
      {
        status: statusOrError.data,
        customerInvoiceSeries: customerInvoiceSeriesOrError.data,
        customerInvoiceNumber: customerInvoiceNumberOrError.data,
        issueDate: issueDateOrError.data,
        operationDate: operationDateOrError.data,
        customerInvoiceCurrency,
        items: itemsOrErrors.data,
      },
      idOrError.data
    );
  }

  public mapToPersistence(
    source: CustomerInvoice,
    params?: MapperParamsType
  ): CustomerInvoiceCreationAttributes {
    const subtotal = source.calculateSubtotal();
    const total = source.calculateTotal();

    const items = this.customerInvoiceItemMapper.mapCollectionToPersistence(source.items, params);

    return {
      id: source.id.toString(),
      invoice_status: source.status.toPrimitive(),
      invoice_series: source.customerInvoiceSeries.toPrimitive(),
      invoice_number: source.customerInvoiceNumber.toPrimitive(),
      issue_date: source.issueDate.toPrimitive(),
      operation_date: source.operationDate.toPrimitive(),
      invoice_language: "es",
      invoice_currency: source.customerInvoiceCurrency || "EUR",

      subtotal_amount: subtotal.amount,
      subtotal_scale: subtotal.scale,

      total_amount: total.amount,
      total_scale: total.scale,

      items,
    };
  }
}

const customerInvoiceMapper: CustomerInvoiceMapper = new CustomerInvoiceMapper();
export { customerInvoiceMapper };