Cron completo y mejora de logs

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

@@ -9,6 +9,7 @@ import { httpInstance } from "#config/httpClient.config.js";
 import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js";
 import { PauseCancelTaskRepository } from "#adapters/PauseCancelTaskRepository.js";
 import { ObjeniousOperationsRepository } from "sim-shared/infrastructure/ObjeniousOperationRepository.js";
+import { ActionData } from "#domain/DTOs/objeniousapi.js";
 
 describe("SimController Integration Tests (Real UseCases)", () => {
   let eventBusMock: any;
@@ -31,13 +32,14 @@ describe("SimController Integration Tests (Real UseCases)", () => {
     );
     const orderRepository = new OrderRepository(postgrClient);
     const pauseRepository = new PauseCancelTaskRepository(postgrClient);
-
     useCases = new SimUseCases({
       httpClient: httpInstance,
       operationRepository: operationRepository,
       orderRepository: orderRepository,
       pauseRepository: pauseRepository
     });
+    // @ts-expect-error
+    useCases.findActivationDate = async (data: ActionData) => new Date()
 
     controller = new SimController(eventBusMock as unknown as EventBus, useCases);
   });
@@ -70,6 +72,7 @@ describe("SimController Integration Tests (Real UseCases)", () => {
       const handler = controller.suspend();
       await handler(msg);
 
+      console.log("Nack: ", eventBusMock.nack.mock.callCount())
       // Verify that it reached the stage_suspend logic (which adds to pauseRepository)
       // We can query the DB or check if ACK was called
       assert.strictEqual(eventBusMock.ack.mock.callCount(), 1, "Message should be ACKed on success");

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

@@ -185,6 +185,7 @@ export class SimController {
       }
 
       const useCaseRes = await this.tryUseCase(msg, this.useCases.stage_suspend(suspendData))
+      console.log("res::", useCaseRes)
       /*
       const res = await this.tryUseCase(msg, this.useCases.suspend(actionData))
       */

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

@@ -6,6 +6,7 @@ import { ObjeniousOperation, IOperationsRepository as OperationsRepositoryPort }
 import assert from "node:assert"
 import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js"
 import { CreatePauseCancelTaskDTO, PauseCancelTaskRepository } from "#adapters/PauseCancelTaskRepository.js"
+import { ObjeniousOperationsRepository } from "sim-shared/infrastructure/ObjeniousOperationRepository.js"
 
 // TODO: 
 // - Pasar a un archivo de DTOs
@@ -13,13 +14,13 @@ import { CreatePauseCancelTaskDTO, PauseCancelTaskRepository } from "#adapters/P
 
 export class SimUseCases {
   private readonly httpClient: HttpClient
-  private readonly objeniousRepository: OperationsRepositoryPort
+  private readonly objeniousRepository: ObjeniousOperationsRepository
   private readonly orderRepository: OrderRepository
   private readonly pauseRepository: PauseCancelTaskRepository
 
   constructor(args: {
     httpClient: HttpClient,
-    operationRepository: OperationsRepositoryPort,
+    operationRepository: ObjeniousOperationsRepository,
     orderRepository: OrderRepository,
     pauseRepository: PauseCancelTaskRepository
   }) {
@@ -243,31 +244,64 @@ export class SimUseCases {
     })
   }
 
+  /**
+   * Metodo muy especifico para obtener la fecha e activacion o en su defecto
+   * la actual para aber cuando se va a completar el periodo de test de una linea
+   */
+  private async findActivationDate(actionData: ActionData) {
+    const iccid = actionData.identifier.identifiers
+    const lineData = await this.objeniousRepository.getLinesAPI("ICCID", iccid)
+    let activationDate = new Date()
+    // Si no se pueden sacar datos de la linea guardo momentaneamente el error
+    // pero no se cancela la operacion, el error puede ser de objenious y no nos 
+    // puede afectar
+    if (lineData.error != undefined) {
+      console.error(lineData.error)
+    } else {
+      const activationDateStr = lineData.data[0].status.activationDate
+      if (activationDateStr != undefined && activationDateStr != "") {
+        activationDate = new Date(activationDateStr)
+      }
+    }
+    return activationDate
+  }
+
+
   /**
   * 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 iccid = suspendData.identifier.identifiers
 
-      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: "suspend"
-      }
-
-      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)
+      const fail = (error: string) => {
+        console.error("[Sim.usecases]", error)
         if (correlation_id != undefined) {
           this.orderRepository.updateOrder({
             correlation_id: correlation_id,
             new_status: "failed"
           })
         }
+      }
+
+      console.log("Preactivationdate", suspendData)
+      const activationDate = await this.findActivationDate(suspendData)
+      console.log("ActivationDate", activationDate)
+
+      const newTask: CreatePauseCancelTaskDTO = {
+        iccid: iccid[0],
+        activation_date: activationDate,
+        next_check: undefined, // Que se haga instantaneamente al ser la primera
+        operation_type: "suspend",
+        actionData: suspendData
+      }
+
+      const taskCreated = await this.pauseRepository.addTask(newTask)
+
+      // Caso que la task no se pueda crear en la BDD
+      if (taskCreated.error != undefined) {
+        fail(taskCreated.error)
         return {
           error: taskCreated.error
         }
@@ -294,11 +328,13 @@ export class SimUseCases {
     return async (): Promise<Result<string, boolean>> => {
       const correlation_id = terminateData.correlation_id
 
+      const activationDate = await this.findActivationDate(terminateData)
       const newTask: CreatePauseCancelTaskDTO = {
         iccid: terminateData.identifier.identifiers[0],
-        activation_date: new Date(), // TODO: BUSCAR LA DE VERDAD
+        activation_date: activationDate,
         next_check: undefined, // Que se haga instantaneamente al ser la primera
-        operation_type: "terminate"
+        operation_type: "terminate",
+        actionData: terminateData
       }
 
       const taskCreated = await this.pauseRepository.addTask(newTask)

packages/sim-consumidor-objenious/infrastructure/PauseCancelTaskRepository.test.ts

@@ -7,7 +7,15 @@ const testTask: CreatePauseCancelTaskDTO = {
   iccid: "1234",
   operation_type: "suspend",
   activation_date: new Date(),
-  next_check: new Date()
+  next_check: new Date(),
+  actionData: {
+    dueDate: new Date().toString(),
+    correlation_id: "12223",
+    identifier: {
+      identifiers: ["1234"],
+      identifierType: "ICCID"
+    }
+  }
 }
 
 describe("Test PauseCancelTaskRepository - DB", () => {
@@ -31,7 +39,7 @@ describe("Test PauseCancelTaskRepository - DB", () => {
     const created = await pauseRepo.addTask(testTask)
     assert.ok(created != undefined, "A value must be returned always")
     assert.ok(created.error == undefined, "Should not return a error")
-    assert.ok(created.data != undefined, "Data mus be returned")
+    assert.ok(created.data != undefined, "Data must be returned")
     createdIds.push(created.data.id)
   })
 
@@ -43,7 +51,7 @@ describe("Test PauseCancelTaskRepository - DB", () => {
 
     assert.ok(updated != undefined, "A value must be returned always")
     assert.ok(updated.error == undefined, "Should not return a error")
-    assert.ok(updated.data != undefined, "Data mus be returned")
+    assert.ok(updated.data != undefined, "Data must be returned")
   })
 
   it("Should finish a existing task", async () => {
@@ -54,6 +62,16 @@ describe("Test PauseCancelTaskRepository - DB", () => {
 
     assert.ok(finish != undefined, "A value must be returned always")
     assert.ok(finish.error == undefined, "Should not return a error")
-    assert.ok(finish.data != undefined, "Data mus be returned")
+    assert.ok(finish.data != undefined, "Data must be returned")
+  })
+
+  it("Should get at least 1 pending task", async () => {
+    const pending = await pauseRepo.getPending()
+
+    assert.ok(pending != undefined, "A value must be returned always")
+    assert.ok(pending.error == undefined, "Should not return a error")
+    assert.ok(pending.data != undefined, "Data must be returned")
+
+    console.log("--> ", pending.data)
   })
 })

packages/sim-consumidor-objenious/infrastructure/PauseCancelTaskRepository.ts

@@ -2,6 +2,7 @@ import { Result } from "sim-shared/domain/Result.js";
 import { QueryResult } from "pg";
 import { PgClient } from "sim-shared/infrastructure/PgClient.js";
 import { AxiosError } from "axios";
+import { ActionData } from "#domain/DTOs/objeniousapi.js";
 
 export type PauseCancelTask = {
   id: number;
@@ -12,9 +13,10 @@ export type PauseCancelTask = {
   next_check?: Date | null;
   completed_date?: Date | null;
   error?: string | null;
+  actionData: ActionData
 }
 
-export type CreatePauseCancelTaskDTO = Pick<PauseCancelTask, "iccid" | "activation_date" | "next_check" | "operation_type">
+export type CreatePauseCancelTaskDTO = Pick<PauseCancelTask, "iccid" | "activation_date" | "next_check" | "operation_type" | "actionData">
 export type UpdatePauseCancelTaskDTO = Pick<PauseCancelTask, "id" | "next_check">
 export type FinishPauseCancelTaskDTO = Pick<PauseCancelTask, "id" | "error">
 
@@ -55,12 +57,12 @@ export class PauseCancelTaskRepository {
   public async addTask(task: CreatePauseCancelTaskDTO): Promise<Result<string, PauseCancelTask>> {
 
     const sql = `
-      INSERT INTO pause_cancel_tasks (iccid, activation_date, next_check, last_checked, operation_type)
-      VALUES ($1, $2, $3, now(), $4)
+      INSERT INTO pause_cancel_tasks (iccid, activation_date, next_check, last_checked, operation_type, actionData)
+      VALUES ($1, $2, $3, now(), $4, $5)
       RETURNING *;
     `;
     try {
-      const values = [task.iccid, task.activation_date, task.next_check, task.operation_type];
+      const values = [task.iccid, task.activation_date, task.next_check, task.operation_type, JSON.stringify(task.actionData)];
       const res: QueryResult<PauseCancelTask> = await this.pgClient.query(sql, values);
       return {
         data: res.rows[0]