sf-sim/packages/sim-consumidor-nos/aplication/SimNOS.usecases.ts

/**
 * Documentación de referencia:
 * https://pelion-help.iot-x.com/nos/en-US/Content/API/APIReference/API%20Reference.htm?tocpath=_____7
 *
 * En nos el correlation_id ya va a ser obligatorio en todos los mensajes
 *
 * TODO:
 * - Control de errores más preciso
 *
 */
import { NosHttpClient } from "#infrastructure/NosHttpClient.js";
import { NosRepository } from "#infrastructure/NosRepository.js";
import { ErrorOrderDTO, FinishOrderDTO, UpdateOrderDTO } from "sim-shared/domain/Order.js";
import { Result } from "sim-shared/domain/Result.js";
import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js";

export class SimNosUsecases {
  constructor(
    private httpClient: NosHttpClient,
    private nosRepository: NosRepository,
    private orderRepository: OrderRepository
  ) {
  }

  private async setRunning(correlation_id: string) {
    // En NOS el updateOrder se hace con el correlation_id que viene en la cabecera del
    // mensaje consumido
    const updateData: UpdateOrderDTO = {
      new_status: "running",
      correlation_id: correlation_id
    }
    const order = await this.orderRepository.updateOrder(updateData)
    return order
  }

  private async setFinished(correlation_id: string) {
    // En NOS el updateOrder se hace con el correlation_id que viene en la cabecera del
    // mensaje consumido
    const updateData: FinishOrderDTO = {
      correlation_id: correlation_id
    }
    const order = await this.orderRepository.finishOrder(updateData)
    return order
  }

  private async setFailed(correlation_id: string, reason: string, detail?: string) {
    // En NOS el updateOrder se hace con el correlation_id que viene en la cabecera del
    // mensaje consumido
    const updateData: ErrorOrderDTO = {
      status: "failed",
      correlation_id: correlation_id,
      reason: reason,
      error: reason,
      stackTrace: detail
    }

    console.log("SET FAILED DATA:", updateData)
    const order = await this.orderRepository.errorOrder(updateData)
    console.log("SET FAILED RES:", order)
    return order
  }

  public usecaseTemplate<T, R>(
    func: (_: T) => Promise<Result<string, R>>,
    args: T,
    correlation_id?: string | undefined
  ) {
    return async () => {
      // Operacion pending -> running
      if (correlation_id != undefined)
        this.setRunning(correlation_id)
          .then()
          .catch(e => console.error("Error actualizando el order", e))

      try {
        const res = await func(args)

        if (res.error != undefined) {
          console.log("Error peticion: ", res, correlation_id)
          if (correlation_id != undefined)
            this.setFailed(correlation_id, res.error)
              .then(e => console.log("failed", e))
              .catch(e => console.error(e))
          return res;
        } else {
          if (correlation_id != undefined)
            this.setFinished(correlation_id).then()
          return res;
        }

      } catch (e) {
        if (correlation_id != undefined)
          this.setFailed(correlation_id, "Error general de operacion de SIM (NOS) ", String(e)).then()
        return {
          error: "Error general de operacion de SIM (NOS) " + String(e)
        }
      }

    }
  }

  public activate(args: {
    iccid: string,
    correlation_id?: string
  }) {
    return this.usecaseTemplate(
      (args) => this.nosRepository.activateSim(args), args.iccid, args.correlation_id)
  }

  public suspend(args: {
    iccid: string,
    correlation_id?: string
  }) {
    return this.usecaseTemplate(
      (args) => this.nosRepository.bar(args), args.iccid, args.correlation_id)
  }

  public reactivate(args: {
    iccid: string,
    correlation_id?: string
  }) {
    return this.usecaseTemplate(
      (args) => this.nosRepository.unbar(args), args.iccid, args.correlation_id)
  }

  public terminate(args: { iccid: string }) {
    throw new Error("No hay termination para NOS")
  }

  /* Importante: Las operaciones de lectua no dejan registro en orders */

  public async selectOne(args: {
    iccid: string
  }) {
    const res = await this.nosRepository.getLineInfo(args.iccid)
    return res
  }

  public async selectPage(args: {
    offset?: number,
    limit?: number,
    filter?: string,
    orderBy?: string
  }) {
    const res = await this.nosRepository.getLinePage(args)
    return res
  }

  /**
  public selectMany(args: {
    iccid: string[]
  }) {
    return {}
  }
*/
}