sf-sim/packages/sim-entrada-eventos/aplication/Sim.usecases.ts

import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js";
import { Result } from "sim-shared/domain/Result.js";
import assert from "node:assert";
import { SimEvents } from "sim-shared/domain/SimEvents.js";
import { uuidv7 } from "uuidv7";
import { CreateOrderDTO, OrderTracking, OrderType, OrderTypeOptions } from "sim-shared/domain/Order.js";
import { EventBus } from "sim-shared/domain/EventBus.port.js";

/**
 * Casos de uso de tarjetas sim. Garantiza que todos los metodos usan el mismo bus de mensajes
 * y repositorio de registro de las ordenes.
 */
export class SimUsecases {
  private eventBus: EventBus;
  private orderRepository: OrderRepository;

  constructor(args: {
    eventBus: EventBus,
    orderRepository: OrderRepository
  }
  ) {
    this.eventBus = args.eventBus
    this.orderRepository = args.orderRepository
  }

  /**
   * Añade un id de mensaje (correlation_id en la base de datos) a los mensajes que van a entrar en la cola
   */
  private addMessage_id(event: SimEvents.general): SimEvents.general & { headers: { message_id: string } } {
    const uuid = uuidv7()
    return {
      ...event,
      headers: {
        ...event.headers,
        message_id: uuid
      }
    }
  }

  /**
   * El tipo T es el tipo del payload del Order 
   */
  private async saveOrder<T extends any>(event: SimEvents.general): Promise<Result<string, OrderTracking<T>>> {
    if (event.headers?.message_id == undefined) {
      return <Result<string, any>>{
        error: "El evento no tiene una cabecera message_id definido"
      }
    }

    const orderType = (event.key.split(".")[2] as OrderType ?? "unknown")

    // Estoy pensando en la posibilidad de pasarlo a unknown
    if (!OrderTypeOptions.has(orderType)) {
      return <Result<string, any>>{
        error: `El evento no tiene un tipo valido: ${orderType} no existe como tipo valido`
      }
    }

    const order: CreateOrderDTO = {
      correlation_id: event.headers.message_id,
      order_type: orderType,
      routing_key: event.key,
      payload: event
    }

    const result = await this.orderRepository.createOrder<T>(order)
    return result;
  }

  async test(args: { iccid: string }) {
    assert(args.iccid != undefined)
    const event = <SimEvents.general>{
      key: `sim.test.unknown`,
      payload: {
        iccid: args.iccid
      }
    }
    const eventWithId = this.addMessage_id(event)

    const publish = await this.eventBus.publish([eventWithId])
    await this.saveOrder(eventWithId)
    return eventWithId
  }

  /**
  * TODO:
  * Crea una nueva sim de la que no se tenia registro anteriormente
  * Si ya existia se modifican los campos pero no se hace un cambio
  * de estado.
  */
  async save(args: { iccid: string, imei: string, compañia: string }) {
    const activationEvent = <SimEvents.save>{
      key: `sim.${args.compañia}.save`,
      payload: {
        iccid: args.iccid,
        imei: args.imei
      }
    }

    return this.eventBus.publish([activationEvent])
  }

  async activation(args: { iccid: string, compañia: string, offer: string }):
    Promise<Result<string, { iccid: string, message_id: string, operation: "activation" }>> {
    const activationEvent = <SimEvents.activation>{
      key: `sim.${args.compañia}.activate`,
      payload: {
        iccid: args.iccid,
        offer: args.offer
      }
    }
    const activationWithId = this.addMessage_id(activationEvent)
    console.log("[d] Activation ", activationWithId)
    await this.eventBus.publish([activationWithId])
    const createdOrder = await this.saveOrder<SimEvents.activation>(activationWithId)

    if (createdOrder.error != undefined) {
      console.error(createdOrder.error)
      return {
        error: createdOrder.error
      }
    }

    return {
      data: {
        iccid: args.iccid,
        operation: "activation",
        message_id: createdOrder.data?.correlation_id
      }
    }
  }

  async reActivation(args: { iccid: string, compañia: string, offer: string }):
    Promise<Result<string, { iccid: string, message_id: string, operation: "reactivate" }>> {
    const activationEvent = <SimEvents.activation>{
      key: `sim.${args.compañia}.reactivate`,
      payload: {
        iccid: args.iccid,
        offer: args.offer
      }
    }
    const activationWithId = this.addMessage_id(activationEvent)
    console.log("[d] Reactivation ", activationWithId)
    await this.eventBus.publish([activationWithId])
    const createdOrder = await this.saveOrder<SimEvents.reActivation>(activationWithId)

    if (createdOrder.error != undefined) {
      console.error(createdOrder.error)
      return {
        error: createdOrder.error
      }
    }

    return {
      data: {
        iccid: args.iccid,
        operation: "reactivate",
        message_id: createdOrder.data?.correlation_id
      }
    }
  }

  async preActivation(args: { iccid: string, compañia: string }):
    Promise<Result<string, { iccid: string, message_id: string, operation: "preactivation" }>> {

    const preActivationEvent = <SimEvents.preActivation>{
      key: `sim.${args.compañia}.preactivate`,
      payload: {
        iccid: args.iccid
      }
    }

    const preActivationWithId = this.addMessage_id(preActivationEvent)
    console.log("[d] Pre - activation ", preActivationWithId)
    await this.eventBus.publish([preActivationWithId])
    const createdOrder = await this.saveOrder<SimEvents.preActivation>(preActivationWithId)
    if (createdOrder.error != undefined) {
      console.error(createdOrder.error)
      return {
        error: createdOrder.error
      }
    }

    return {
      data: {
        iccid: args.iccid,
        operation: "preactivation",
        message_id: createdOrder.data?.correlation_id
      }
    }
  }

  /**
   * Para objenious es terminate
   */
  async cancelation(args: { iccid: string, compañia: string }):
    Promise<Result<string, { iccid: string, message_id: string, operation: "cancelation" }>> {

    const cancelationEvent = <SimEvents.cancel>{
      key: `sim.${args.compañia}.cancel`,
      payload: {
        iccid: args.iccid
      }
    }

    const cancelationWithId = this.addMessage_id(cancelationEvent)
    console.log("[d] Cancelation ", cancelationWithId)

    await this.eventBus.publish([cancelationWithId])
    const savedOrder = await this.saveOrder(cancelationWithId)

    if (savedOrder.error != undefined) {
      console.error(savedOrder.error)
      return {
        error: savedOrder.error
      }
    }

    return {
      data: {
        iccid: args.iccid,
        message_id: savedOrder.data.correlation_id,
        operation: "cancelation"
      }
    }
  }
  // alias por si acaso
  public terminate = this.cancelation;

  /**
   * alias de bloquear / suspender en objenious
   */
  async pause(args: { iccid: string, compañia: string }):
    Promise<Result<string, { iccid: string, message_id: string, operation: "pause" }>> {
    const pauseEvent = <SimEvents.pause>{
      key: `sim.${args.compañia}.pause`,
      payload: {
        iccid: args.iccid
      }
    }

    const pauseWithId = this.addMessage_id(pauseEvent)
    console.log("[d] Pause", pauseWithId)
    await this.eventBus.publish([pauseWithId])
    //await this.saveOrder(pauseWithId)
    const savedOrder = await this.saveOrder<SimEvents.pause>(pauseWithId)

    if (savedOrder.error != undefined) {
      console.error(savedOrder.error)
      return {
        error: savedOrder.error
      }
    }

    return {
      data: {
        iccid: args.iccid,
        message_id: savedOrder.data.correlation_id,
        operation: "pause"
      }
    }
  }

  async free(args: { iccid: string, compañia: string }) {
    const cancelationEvent = <SimEvents.free>{
      key: `sim.${args.compañia}.free`,
      payload: {
        iccid: args.iccid
      }
    }

    return this.eventBus.publish([cancelationEvent])
  }

}