sf-sim/packages/sim-objenious-cron/tasks/check_objenious_request.ts

import { IOperationsRepository, Objenious, ObjeniousOperation, ObjeniousOperationChange, StatusEnum } from "#objenious-shared/domain/operationsRepository.port.js"
import { HttpClient } from "#shared/infrastructure/HTTPClient.js";
import { constants } from "node:buffer";

export class CheckObjeniousRequests {
  constructor(
    private readonly operationsRepository: IOperationsRepository,
    private readonly httpClient: HttpClient
  ) {
  }

  /**
   * TODO: meter a una funcion a parte task con los 3 pasos
   */
  public async getPendingOperations() {
    const pendingOperations = await this.operationsRepository.getPendingOperations()


    if (pendingOperations.error != undefined) {
      throw new Error("Error obteniendo las tareas pendientes " + pendingOperations.error)
    }

    if (pendingOperations.data == undefined || pendingOperations.data.length == 0) {
      //Nada pendiente
      return;
    }

    const erroneas = pendingOperations.data
      .filter((e) => e.request_id == undefined)

    const operacionesValidas = pendingOperations.data
      .filter((e) => e.request_id != undefined)

    const solicitarMassId = operacionesValidas
      .filter((e) => e.mass_action_id == undefined)

    const consultarEstado = pendingOperations.data
      .filter(e => e.mass_action_id != undefined)

    console.log("validas", operacionesValidas)
    console.log("Solicitando mass id para", solicitarMassId)

    const newMassActions = await this.getMassIdFromRequest(solicitarMassId)

    const merged = [...newMassActions || [], ...consultarEstado]

    console.log("Solicitando status para", merged)

    const result = await this.getMassActionsStatus(merged)
  }

  private async getMassActionsStatus(requestList: ObjeniousOperation[]) {
    if (requestList.length == 0) return;

    const operationsList = structuredClone(requestList)
    const PATH = "/actions/massActions/"
    const updated = []

    const iccids = operationsList
      .map(e => e.iccids)
      .flat()

    const mass_actions = operationsList
      .filter(e => e.mass_action_id != undefined)

    const iccidSet = new Set<string>(iccids)
    console.log("iccidSet", iccidSet)

    // 1. Una peticion por cada accion a comprobar
    //    Las peticiones por iccid u otro filtro tardan ~50s
    for (const originalAction of mass_actions) {

      const req = this.httpClient.client.get<Objenious.ResponseGetMassAction>(PATH + originalAction.mass_action_id, {
        params: <Objenious.ParametersGetMassAction>{
        }
      })

      let res;
      // 1. Comprobacion de la request.
      try {
        res = await req
      } catch (e) {
        console.error("Error comprobando el estado de ", originalAction)
        console.error("Error: ", e)
        return;
      }

      const { data } = res

      console.log("Estado de : ", originalAction.mass_action_id, originalAction.iccids)
      console.log(res.status, data)

      if (res.status != 200 || data == undefined) {
        console.error("Error buscando los massActions")
        continue;
      }

      // 2. Se comprueba si ha habido un cambio de estado
      const { id, status, info } = data

      if (status != originalAction.objenious_status) {
        console.log(status, "!=", originalAction.objenious_status)
        console.log("Actualizando", originalAction, status)
        const uorStatus = this.mapStatus(status)
        const updateData: ObjeniousOperationChange = {
          operation_id: originalAction.id!,
          new_objenious_status: status,
          previous_objenious_status: originalAction.objenious_status,
          new_status: uorStatus,
          previous_status: originalAction.status
        }

        originalAction.status = uorStatus;
        originalAction.objenious_status = status;
        originalAction.last_change_date = new Date().toISOString()

        if (info != undefined) {
          updateData.info = info
        }

        try {
          console.log("Subiendo un update")
          console.log(updateData)
          await this.operationsRepository.updateOperation(updateData)
          updated.push(originalAction)
        } catch (e) {
          console.error("Error actualizando el estado de ", originalAction, e)
          return;
        }
      }
    }
  }

  private mapStatus(objStatus: string) {
    const sanitizedStatus = objStatus.trim().toLowerCase()
    // No tengo el resto porque no aparecen en la documentación
    // asumo que todos los demas sn running y se deben volver a comrobar
    const equivalentMap = new Map<string, StatusEnum>([
      ["terminé", "finished"]
    ])
    const res = equivalentMap.get(sanitizedStatus)
    if (res == undefined) return "running"
    return res
  }

  /**
  * Refrescar los requests hasta que conseguir una Id de mass action
  * Como no se puede consultar por 
  *
  */
  private async getMassIdFromRequest(requestList: ObjeniousOperation[]) {
    if (requestList.length == 0) return;

    const PATH = "/actions/requests/"
    const operationsList = structuredClone(requestList)


    for (const request of operationsList) {
      if (request.id == undefined) continue;

      const req = this.httpClient.client.get<Objenious.ResponseGetRequestById>(PATH + request.request_id, {
      })

      let res;

      // 1. Comprobacion de la request.
      try {
        res = await req
      } catch (e) {
        console.error("Error comprobando el estado de ", request, e)
        //todo actualizar el estado para incluir el error
        continue;
      }

      // 2. Modificacion del massId si ha habido un cambio
      const massActionId = res.data.massActionIds[0]
      try {
        if (res.status == 200 && res.data != undefined && massActionId != undefined) {
          const updateData: ObjeniousOperationChange = {
            operation_id: request.id,
            new_status: "running",
            new_mass_action_id: String(massActionId)
          }

          await this.operationsRepository.updateOperation(updateData)
          //! Se actualiza el registro para futuras operaciones
          request.mass_action_id = String(massActionId)
        }
      } catch (e) {
        console.log("Error actualizando el estado de ", request)
        continue;
      }

    }

    // 3. Se devuelve la lista de los requests con las actualizaciones
    return operationsList
  }
}