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

import {
  ISequelizeMapper,
  MapperParamsType,
  SequelizeMapper,
  ValidationErrorCollection,
  ValidationErrorDetail,
  extractOrPushError,
} from "@erp/core/api";
import {
  CurrencyCode,
  LanguageCode,
  Percentage,
  TextValue,
  UniqueID,
  UtcDate,
  maybeFromNullableVO,
} from "@repo/rdx-ddd";
import { Result } from "@repo/rdx-utils";
import {
  CustomerInvoice,
  CustomerInvoiceNumber,
  CustomerInvoiceProps,
  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 _itemsMapper: CustomerInvoiceItemMapper;

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

  public mapToDomain(
    source: CustomerInvoiceModel,
    params?: MapperParamsType
  ): Result<CustomerInvoice, Error> {
    try {
      const errors: ValidationErrorDetail[] = [];

      const invoiceId = extractOrPushError(UniqueID.create(source.id), "id", errors);
      const companyId = extractOrPushError(
        UniqueID.create(source.company_id),
        "company_id",
        errors
      );

      const status = extractOrPushError(
        CustomerInvoiceStatus.create(source.status),
        "status",
        errors
      );

      const series = extractOrPushError(
        maybeFromNullableVO(source.series, (value) => CustomerInvoiceSerie.create(value)),
        "serie",
        errors
      );

      const invoiceNumber = extractOrPushError(
        CustomerInvoiceNumber.create(source.invoice_number),
        "invoice_number",
        errors
      );

      const invoiceDate = extractOrPushError(
        UtcDate.createFromISO(source.invoice_date),
        "invoice_date",
        errors
      );

      const operationDate = extractOrPushError(
        maybeFromNullableVO(source.operation_date, (value) => UtcDate.createFromISO(value)),
        "operation_date",
        errors
      );

      const notes = extractOrPushError(
        maybeFromNullableVO(source.notes, (value) => TextValue.create(value)),
        "notes",
        errors
      );

      const languageCode = extractOrPushError(
        LanguageCode.create(source.language_code),
        "language_code",
        errors
      );

      const currencyCode = extractOrPushError(
        CurrencyCode.create(source.currency_code),
        "currency_code",
        errors
      );

      const discountPercentage = extractOrPushError(
        Percentage.create({
          value: source.discount_percentage_value,
          scale: source.discount_percentage_scale,
        }),
        "discount_percentage",
        errors
      );

      if (errors.length > 0) {
        return Result.fail(
          new ValidationErrorCollection("Customer invoice props mapping failed", errors)
        );
      }

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

      if (errors.length > 0) {
        return Result.fail(
          new ValidationErrorCollection("Customer invoice item props mapping failed", errors)
        );
      }

      const invoiceProps: CustomerInvoiceProps = {
        companyId: companyId!,
        status: status!,
        series: series!,
        invoiceNumber: invoiceNumber!,
        invoiceDate: invoiceDate!,
        operationDate: operationDate!,

        notes: notes!,

        languageCode: languageCode!,
        currencyCode: currencyCode!,

        discountPercentage: discountPercentage!,

        items: items!,
      };

      return CustomerInvoice.create(invoiceProps, invoiceId);
    } catch (err: unknown) {
      return Result.fail(err as Error);
    }
  }

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

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

    return {
      id: source.id.toString(),
      invoice_status: source.status.toPrimitive(),
      invoice_series: source.invoiceSeries.toPrimitive(),
      invoice_number: source.invoiceNumber.toPrimitive(),
      invoice_date: source.invoiceDate.toPrimitive(),
      operation_date: source.operationDate.toPrimitive(),
      invoice_language: "es",
      invoice_currency: source.currency || "EUR",

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

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

      items,
    };
  }
}