Usecases

packages/sim-consumidor-objenious/aplication/Sim.controller.ts

@@ -178,7 +178,7 @@ export class SimController {
         dueDate: this.genDueDate(2 * 60).toISOString(),
         identifier: {
           identifierType: "ICCID",
-          identifiers: [iccid]
+          identifiers: [iccid] // Por algún motivo solo he puesto un iccd por identifier
         }
       }))
 

packages/sim-consumidor-objenious/aplication/Sim.usecases.ts

@@ -5,6 +5,7 @@ import { Result } from "sim-shared/domain/Result.js"
 import { ObjeniousOperation, IOperationsRepository as OperationsRepositoryPort } from "sim-shared/domain/operationsRepository.port.js"
 import assert from "node:assert"
 import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js"
+import { CreatePauseCancelTaskDTO, PauseCancelTaskRepository } from "#adapters/PauseCancelTaskRepository.js"
 
 // TODO: 
 // - Pasar a un archivo de DTOs
@@ -12,21 +13,24 @@ import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js"
 
 export class SimUseCases {
   private readonly httpClient: HttpClient
-  private readonly operationRepository: OperationsRepositoryPort
+  private readonly objeniousRepository: OperationsRepositoryPort
   private readonly orderRepository: OrderRepository
+  private readonly pauseRepository: PauseCancelTaskRepository
 
   constructor(args: {
     httpClient: HttpClient,
     operationRepository: OperationsRepositoryPort,
-    orderRepository: OrderRepository
+    orderRepository: OrderRepository,
+    pauseRepository: PauseCancelTaskRepository
   }) {
     this.httpClient = args.httpClient
-    this.operationRepository = args.operationRepository
+    this.objeniousRepository = args.operationRepository
     this.orderRepository = args.orderRepository
+    this.pauseRepository = args.pauseRepository
   }
 
   private async logOperation(data: ObjeniousOperation) {
-    await this.operationRepository.createOperation({
+    await this.objeniousRepository.createOperation({
       ...data
     })
   }
@@ -73,6 +77,8 @@ export class SimUseCases {
             request_id: response.data.requestId
           }
 
+          // TODO: Esto tiene poco sentido si la operacion ya se
+          // tenia que haber creado en el generador
           this.logOperation(operation)
             .then().catch(e => console.error(e))
 
@@ -238,6 +244,93 @@ export class SimUseCases {
     })
   }
 
+  /**
+  * Paso previo a la suspension para evitar errores cuando el billing es test
+  */
+  public stage_suspend(suspendData: ActionData): () => Promise<Result<string, boolean>> {
+    return async (): Promise<Result<string, boolean>> => {
+      const correlation_id = suspendData.correlation_id
+
+      const newTask: CreatePauseCancelTaskDTO = {
+        iccid: suspendData.identifier.identifiers[0],
+        activation_date: new Date(), // TODO: BUSCAR LA DE VERDAD
+        next_check: undefined, // Que se haga instantaneamente al ser la primera
+        operation_type: "terminate"
+      }
+
+      const taskCreated = await this.pauseRepository.addTask(newTask)
+
+      // Caso que la task no se pueda crear en la BDD
+      if (taskCreated.error != undefined) {
+        console.error("[Sim.usecases]", taskCreated.error)
+        if (correlation_id != undefined) {
+          this.orderRepository.updateOrder({
+            correlation_id: correlation_id,
+            new_status: "failed"
+          })
+        }
+        return {
+          error: taskCreated.error
+        }
+      }
+
+      // Caso que se haya creado en la BDD
+      if (correlation_id != undefined) {
+        this.orderRepository.updateOrder({
+          correlation_id: correlation_id,
+          new_status: "running"
+        })
+      }
+
+      return {
+        data: true
+      }
+    }
+  }
+
+  /**
+  * Paso previo a la suspension para evitar errores cuando el billing es test
+  */
+  public stage_terminate(terminateData: ActionData): () => Promise<Result<string, boolean>> {
+    return async (): Promise<Result<string, boolean>> => {
+      const correlation_id = terminateData.correlation_id
+
+      const newTask: CreatePauseCancelTaskDTO = {
+        iccid: terminateData.identifier.identifiers[0],
+        activation_date: new Date(), // TODO: BUSCAR LA DE VERDAD
+        next_check: undefined, // Que se haga instantaneamente al ser la primera
+        operation_type: "terminate"
+      }
+
+      const taskCreated = await this.pauseRepository.addTask(newTask)
+
+      // Caso que la task no se pueda crear en la BDD
+      if (taskCreated.error != undefined) {
+        console.error("[Sim.usecases]", taskCreated.error)
+        if (correlation_id != undefined) {
+          this.orderRepository.updateOrder({
+            correlation_id: correlation_id,
+            new_status: "failed"
+          })
+        }
+        return {
+          error: taskCreated.error
+        }
+      }
+
+      // Caso que se haya creado en la BDD
+      if (correlation_id != undefined) {
+        this.orderRepository.updateOrder({
+          correlation_id: correlation_id,
+          new_status: "running"
+        })
+      }
+
+      return {
+        data: true
+      }
+    }
+  }
   public terminate(terminationData: ActionData): () => Promise<Result<string, boolean>> {
     const OPERATION_URL = "/actions/terminateLine"
     return this.generateUseCase({