Presupuestador_web/server/src/contexts/sales/application/Quote/UpdateQuote.useCase.ts

import { createQuoteChapters } from "../services/createQuoteChapters";
import { ensureQuoteChapterStructureIsValid } from "@shared/contexts";
import {
  IUseCase,
  IUseCaseError,
  IUseCaseRequest,
  UseCaseError,
} from "@/contexts/common/application";
import { IRepositoryManager } from "@/contexts/common/domain";
import { ISequelizeAdapter } from "@/contexts/common/infrastructure/sequelize";
import {
  Collection,
  CurrencyData,
  Description,
  DomainError,
  IDomainError,
  Language,
  Note,
  Percentage,
  Quantity,
  Result,
  TextValueObject,
  UTCDateValue,
  UniqueID,
  UnitPrice,
} from "@shared/contexts";

import { ArticleIdentifier } from "@/contexts/catalog/domain";
import { IUpdateQuote_Request_DTO } from "@shared/contexts";
import {
  Dealer,
  IQuoteRepository,
  Quote,
  QuoteCustomer,
  QuoteCustomerReference,
  QuoteItem,
  QuoteReference,
  QuoteStatus,
} from "../../domain";
import { ISalesContext } from "../../infrastructure";

export interface IUpdateQuoteUseCaseRequest extends IUseCaseRequest {
  id: UniqueID;
  quoteDTO: IUpdateQuote_Request_DTO;
}

export type UpdateQuoteResponseOrError =
  | Result<never, IUseCaseError> // Misc errors (value objects)
  | Result<Quote, never>; // Success!

export class UpdateQuoteUseCase
  implements IUseCase<IUpdateQuoteUseCaseRequest, Promise<UpdateQuoteResponseOrError>>
{
  private _adapter: ISequelizeAdapter;
  private _repositoryManager: IRepositoryManager;
  private _dealer?: Dealer;
  private _catalogArticles?: ISalesContext["catalogArticles"];

  constructor(context: ISalesContext) {
    this._adapter = context.adapter;
    this._repositoryManager = context.repositoryManager;
    this._dealer = context.dealer;
    this._catalogArticles = context.catalogArticles;
  }

  async execute(request: IUpdateQuoteUseCaseRequest): Promise<UpdateQuoteResponseOrError> {
    const { id, quoteDTO } = request;
    const QuoteRepository = this._getQuoteRepository();

    // Validaciones de datos
    if (!this._dealer) {
      const message = "Error. Missing Dealer";
      return Result.fail(UseCaseError.create(UseCaseError.INVALID_INPUT_DATA, message));
    }

    const dealerId = this._dealer.id;

    const chapterValidation = ensureQuoteChapterStructureIsValid(quoteDTO);
    if (chapterValidation.isFailure) {
      return Result.fail(UseCaseError.create(UseCaseError.INVALID_INPUT_DATA, chapterValidation.error.message));
    }

    const catalogValidation = await this._validateCatalogItems(quoteDTO.items ?? []);
    if (catalogValidation.isFailure) return Result.fail(catalogValidation.error);

    const transaction = this._adapter.startTransaction();
    try {
      return await transaction.complete(async (t) => {
        const quoteRepo = QuoteRepository({ transaction: t });
        // Comprobar que existe el Quote
        const existingQuote = await quoteRepo.getById(id, { forUpdate: true });
        if (!existingQuote) {
          const message = `Quote ID not found`;
          return Result.fail(
            UseCaseError.create(UseCaseError.NOT_FOUND_ERROR, message, {
              path: "id",
            })
          );
        }

        if ((existingQuote.chapters?.length ?? 0) > 0 && quoteDTO.chapters === undefined) {
          return Result.fail(UseCaseError.create(
            UseCaseError.INVALID_INPUT_DATA,
            "Updating a grouped quote requires an explicit chapters structure",
            { path: "chapters" }
          ));
        }

        // //
        // regla de negocio -> no poder modificar un quote enviado

        // Crear quote
        const quoteOrError = this._tryCreateQuoteInstance(
          quoteDTO,
          id,
          dealerId,
          existingQuote.showLineDiscountColumn,
          existingQuote.taxLabel,
          existingQuote.showChapterLineAmounts
        );

        if (quoteOrError.isFailure) {
          const { error: domainError } = quoteOrError;
          let errorCode = "";
          let message = "";

          switch (domainError.code) {
            // Errores manuales
            case DomainError.INVALID_INPUT_DATA:
              errorCode = UseCaseError.INVALID_INPUT_DATA;
              message = "El presupuesto tiene algún dato erróneo.";
              break;

            default:
              errorCode = UseCaseError.UNEXCEPTED_ERROR;
              message = domainError.message;
              break;
          }

          return Result.fail(UseCaseError.create(errorCode, message, domainError));
        }

        await quoteRepo.update(quoteOrError.object);
        return Result.ok<Quote>(quoteOrError.object);
      });
    } catch (error: unknown) {
      return Result.fail(UseCaseError.create(UseCaseError.REPOSITORY_ERROR, (error as Error).message));
    }
  }

  private _tryCreateQuoteInstance(
    quoteDTO: IUpdateQuote_Request_DTO,
    quoteId: UniqueID,
    dealerId: UniqueID,
    existingShowLineDiscountColumn: boolean,
    existingTaxLabel: Note,
    existingShowChapterLineAmounts: boolean = true
  ): Result<Quote, IDomainError> {
    const statusOrError = QuoteStatus.create(quoteDTO.status);
    if (statusOrError.isFailure) {
      return Result.fail(statusOrError.error);
    }

    const dateOrError = UTCDateValue.create(quoteDTO.date);
    if (dateOrError.isFailure) {
      return Result.fail(dateOrError.error);
    }

    const referenceOrError = QuoteReference.create(quoteDTO.reference);
    if (referenceOrError.isFailure) {
      return Result.fail(referenceOrError.error);
    }

    const languageOrError = Language.createFromCode(
      quoteDTO.lang_code || Language.DEFAULT_LANGUAGE_CODE
    );
    if (languageOrError.isFailure) {
      return Result.fail(languageOrError.error);
    }

    const customerReferenceOrError = QuoteCustomerReference.create(quoteDTO.customer_reference);
    if (customerReferenceOrError.isFailure) {
      return Result.fail(customerReferenceOrError.error);
    }

    const customerOrError = QuoteCustomer.create(quoteDTO.customer_information);
    if (customerOrError.isFailure) {
      return Result.fail(customerOrError.error);
    }

    const currencyOrError = CurrencyData.createFromCode(quoteDTO.currency_code);
    if (currencyOrError.isFailure) {
      return Result.fail(currencyOrError.error);
    }

    const additionalCurrencyOrError = quoteDTO.additional_currency_code
      ? CurrencyData.createFromCode(quoteDTO.additional_currency_code)
      : undefined;
    if (additionalCurrencyOrError?.isFailure ||
      (additionalCurrencyOrError && (!quoteDTO.additional_currency_rate || !quoteDTO.additional_currency_date))) {
      return Result.fail(additionalCurrencyOrError?.error ?? DomainError.create(DomainError.INVALID_INPUT_DATA, "Additional currency requires rate and date"));
    }
    const additionalCurrencyDateOrError = quoteDTO.additional_currency_code
      ? UTCDateValue.create(quoteDTO.additional_currency_date ?? "")
      : undefined;
    if (additionalCurrencyDateOrError?.isFailure) return Result.fail(additionalCurrencyDateOrError.error);

    const paymentOrError = Note.create(quoteDTO.payment_method);
    if (paymentOrError.isFailure) {
      return Result.fail(paymentOrError.error);
    }

    const notesOrError = TextValueObject.create(quoteDTO.notes);
    if (notesOrError.isFailure) {
      return Result.fail(notesOrError.error);
    }

    const validityOrError = Note.create(quoteDTO.validity);
    if (validityOrError.isFailure) {
      return Result.fail(validityOrError.error);
    }

    const discountOrError = Percentage.create(quoteDTO.discount);
    if (discountOrError.isFailure) {
      return Result.fail(discountOrError.error);
    }

    const taxOrError = Percentage.create(quoteDTO.tax);
    if (taxOrError.isFailure) {
      return Result.fail(taxOrError.error);
    }

    const dateSentOrError = UTCDateValue.create(null);
    if (dateSentOrError.isFailure) {
      return Result.fail(dateSentOrError.error);
    }

    const chapters = createQuoteChapters(quoteDTO.chapters, quoteId);
    if (chapters.isFailure) return Result.fail(chapters.error);

    // Items

    let items: Collection<QuoteItem>;

    try {
      items = new Collection<QuoteItem>(
        quoteDTO.items?.map((item) => {
          const idArticleOrError = ArticleIdentifier.create(item.id_article);
          if (idArticleOrError.isFailure) {
            throw idArticleOrError.error;
          }

          const descriptionOrError = Description.create(item.description);
          if (descriptionOrError.isFailure) {
            throw descriptionOrError.error;
          }

          const quantityOrError = Quantity.create({
            amount: item.quantity.amount,
            scale: item.quantity.scale,
          });
          if (quantityOrError.isFailure) {
            throw quantityOrError.error;
          }

          const unitPriceOrError = UnitPrice.create({
            amount: item.unit_price?.amount,
            currencyCode: item.unit_price?.currency_code,
            scale: item.unit_price?.scale,
          });
          if (unitPriceOrError.isFailure) {
            throw unitPriceOrError.error;
          }

          const percentageOrError = Percentage.create({
            amount: item.discount?.amount,
            scale: item.discount?.scale,
          });
          if (percentageOrError.isFailure) {
            throw percentageOrError.error;
          }

          const chapterId = item.chapter_id ? UniqueID.create(item.chapter_id) : undefined;
          if (chapterId?.isFailure) throw chapterId.error;
          const quoteItemOrError = QuoteItem.create({
            chapterId: chapterId?.object ?? null,
            idArticle: idArticleOrError.object,
            description: descriptionOrError.object,
            quantity: quantityOrError.object,
            unitPrice: unitPriceOrError.object,
            discount: percentageOrError.object,
          });

          if (quoteItemOrError.isFailure) {
            throw quoteItemOrError.error;
          }

          return quoteItemOrError.object;
        })
      );
    } catch (e: unknown) {
      return Result.fail(e as IDomainError);
    }

    return Quote.create(
      {
        status: statusOrError.object,
        date: dateOrError.object,
        reference: referenceOrError.object,
        language: languageOrError.object,
        customerReference: customerReferenceOrError.object,
        customer: customerOrError.object,
        currency: currencyOrError.object,
        paymentMethod: paymentOrError.object,
        notes: notesOrError.object,
        validity: validityOrError.object,
        showLineDiscountColumn:
          quoteDTO.show_line_discount_column ?? existingShowLineDiscountColumn,
        additionalCurrency: additionalCurrencyOrError?.object,
        additionalCurrencyRate: quoteDTO.additional_currency_code ? quoteDTO.additional_currency_rate ?? null : null,
        additionalCurrencyDate: additionalCurrencyDateOrError?.object,

        discount: discountOrError.object,
        tax: taxOrError.object,
        taxLabel: existingTaxLabel,

        items,
        chapters: chapters.object,
        showChapterLineAmounts: quoteDTO.show_chapter_line_amounts ?? existingShowChapterLineAmounts,

        dealerId,

        dateSent: dateSentOrError.object,
      },
      quoteId
    );
  }

  private _getQuoteRepository() {
    return this._repositoryManager.getRepository<IQuoteRepository>("Quote");
  }

  private async _validateCatalogItems(items: IUpdateQuote_Request_DTO["items"]): Promise<Result<boolean, IUseCaseError>> {
    const ids: ArticleIdentifier[] = [];
    for (const item of items) {
      const idOrError = ArticleIdentifier.create(item.id_article);
      if (idOrError.isFailure) {
        return Result.fail(UseCaseError.create(UseCaseError.INVALID_INPUT_DATA, idOrError.error.message));
      }
      if (!idOrError.object.isNull()) ids.push(idOrError.object);
    }
    if (!ids.length) return Result.ok(true);
    if (!this._catalogArticles) {
      return Result.fail(UseCaseError.create(UseCaseError.REPOSITORY_ERROR, "Catalog lookup is not configured"));
    }
    const lookup = await this._catalogArticles.execute(ids);
    if (lookup.isFailure) return Result.fail(lookup.error);
    const found = new Set(lookup.object.map((article) => article.idArticle.toString()));
    const missing = ids.find((id) => !found.has(id.toString()));
    return missing
      ? Result.fail(UseCaseError.create(UseCaseError.INVALID_INPUT_DATA, `Catalog article ${missing.toString()} not found`))
      : Result.ok(true);
  }
}