apacuana-sdk-core 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apacuana-sdk-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Core SDK para interacciones con las APIs de Apacuana.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/api/certs.js

@@ -1,30 +1,18 @@
-import CryptoJS from "crypto-js";
-import { getConfig } from "../config";
-import { INTEGRATION_TYPE } from "../utils/constant";
-import { helpers } from "../utils/helpers";
-import { ApacuanaAPIError } from "../errors/index";
+import { getConfig } from "../config/index";
 import { httpRequest } from "../utils/httpClient";
+import helpers from "../utils/helpers";
+import { ApacuanaAPIError } from "../errors";
+import { INTEGRATION_TYPE } from "../utils/constant";
 
-const generateCertOnBoarding = async () => {
+const generateCertOnBoarding = async (csr = undefined) => {
   try {
-    const config = getConfig();
-    const { userData } = config;
-    const keyPair = await helpers.generateKeyPair();
-    const { csrBase64 } = await helpers.generateCSR(keyPair, userData);
-
-    const body = {
-      csr: CryptoJS.AES.encrypt(csrBase64, config.secretKey, {
-        mode: CryptoJS.mode.ECB,
-        padding: CryptoJS.pad.Pkcs7,
-      }).toString(),
-    };
+    const encryptedCSR = helpers.encryptedCsr(csr);
 
     const response = await httpRequest(
       "services/api/register/certificate",
-      body,
+      encryptedCSR,
       "POST"
     );
-
     const { cert } = response;
     if (!cert) {
       throw new ApacuanaAPIError(
@@ -34,11 +22,7 @@ const generateCertOnBoarding = async () => {
       );
     }
 
-    const exportedPrivateKey = await helpers.exportPrivateKey(
-      keyPair.privateKey
-    );
-
-    return { cert, privateKey: exportedPrivateKey };
+    return { cert, success: true };
   } catch (error) {
     // Se lanza el error capturado, que ya será de tipo ApacuanaAPIError o un Error nativo.
     if (error instanceof ApacuanaAPIError) {
@@ -48,23 +32,36 @@ const generateCertOnBoarding = async () => {
   }
 };
 
-export const generateCert = async () => {
+export const generateCert = async (csr = undefined) => {
   const { integrationType } = getConfig();
-
+  helpers.validateCsr(csr);
   if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
-    await generateCertOnBoarding();
-  } else if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return generateCertOnBoarding(csr);
+  }
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
     // eslint-disable-next-line no-console
     console.log("-> Lógica para On-premise");
     // Aquí iría la llamada a httpRequest para el endpoint de on-premise
     // return httpRequest('/certs/generate-onpremise', data);
+    return Promise.resolve(); // Retornar una promesa resuelta para consistencia
   }
+
+  // Lanzar un error si el tipo de integración no es soportado
+  throw new ApacuanaAPIError(
+    `Tipo de integración no soportado: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
 };
 
-export const getCertStatus = () => {
+export const getCertStatus = (isCertificateInDevice = false) => {
   const config = getConfig();
-  const status = helpers.getCertificateStatus(config.userData, false);
+  const status = helpers.getCertificateStatus(
+    config.userData,
+    isCertificateInDevice
+  );
   return {
     status,
+    success: true,
   };
 };

package/src/api/signatures.js

@@ -1,77 +1,232 @@
 // src/api/signatures.js
-import { httpRequest } from '../utils/httpClient';
-import { ApacuanaAPIError } from '../errors/index';
-
-/**
- * Simula la firma de un documento.
- * @param {object} documentData - Datos del documento a firmar.
- * @param {object} signatureData - Datos de la firma.
- * @returns {Promise<object>} Objeto con el resultado de la firma.
- */
-export const signDocument = async (documentData, signatureData) => {
-  console.log("-> Función 'signDocument' ejecutada.");
-  console.log('Parámetros recibidos para firmar documento:', {
-    documentData,
-    signatureData,
-  });
-
-  if (!documentData || !signatureData) {
-    throw new Error(
-      'Datos de documento y firma son requeridos para signDocument.',
-    );
-  }
+import { getConfig } from "../config/index";
+import { httpRequest } from "../utils/httpClient";
+import { ApacuanaAPIError } from "../errors";
+import helpers from "../utils/helpers";
+import { INTEGRATION_TYPE } from "../utils/constant";
 
+/*
+const signDocumentOnBoarding = async (documentData, signatureData) => {
   try {
     const response = await httpRequest(
-      '/docs/sign',
+      "/docs/sign",
       { documentData, signatureData },
-      'POST',
-    );
-    console.log(
-      'Respuesta del servidor simulada para firmar documento:',
-      response,
+      "POST"
     );
     if (!response.success) {
       throw new ApacuanaAPIError(
-        response.message || 'Error desconocido al firmar documento.',
+        response.message || "Error desconocido al firmar documento."
       );
     }
     return { signedDocId: response.id, status: response.message };
   } catch (error) {
-    throw new Error(`Fallo en la firma del documento: ${error.message}`);
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Fallo en la firma del documento (on-boarding): ${error.message}`
+    );
+  }
+};
+
+const signDocumentOnPremise = async (signature, cert, privateKey) => {
+  helpers.validateSignOnPremiseData({ signature, cert, privateKey });
+  try {
+    const digestBody = {
+      publickey: cert,
+    };
+
+    const digestResponse = await httpRequest(
+      `services/api/documents/getdigest/${signature.id}`,
+      digestBody,
+      "POST"
+    );
+
+    const digest = digestResponse.data?.digest || digestResponse.digest;
+    if (!digest) {
+      throw new ApacuanaAPIError(
+        "La generación de firma ha fallado: no se pudo obtener el digest del documento."
+      );
+    }
+
+    const signedDigest = await helpers.signDigest(digest, privateKey);
+
+    const signBody = {
+      positions: JSON.stringify(
+        signature.positions.map((p) => ({
+          x: p.x,
+          y: p.y,
+          page: p.page,
+          status: 1,
+        }))
+      ),
+      publickey: cert,
+      signeddigest: signedDigest,
+    };
+
+    const signResponse = await httpRequest(
+      `services/api/documents/sign/${signature.id}`,
+      signBody,
+      "PUT"
+    );
+
+    return signResponse;
+  } catch (error) {
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Fallo en la firma del documento (on-premise): ${error.message}`
+    );
+  }
+};
+*/
+
+/**
+ * Firma un documento PDF con un certificado digital.
+ * @param {object} data - Datos para la firma. Para 'on-boarding', debe contener {documentData, signatureData}. Para 'on-premise', debe contener {signature, cert, privateKey}.
+ * @returns {Promise<object>} Objeto con el resultado de la firma.
+ */
+/*
+export const signDocument = async (signData) => {
+  if (
+    !signData ||
+    typeof signData !== "object" ||
+    Object.keys(signData).length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      "El parámetro 'data' es requerido y debe ser un objeto no vacío.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return signDocumentOnBoarding(signData);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return signDocumentOnPremise(signData);
+  }
+
+  throw new ApacuanaAPIError(
+    `Tipo de integración no soportado: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+*/
+
+const addSignerOnBoarding = async (signerData) => {
+  helpers.validateOnBoardingSignerData(signerData);
+  try {
+    // La lógica actual de httpRequest se mueve aquí
+    await httpRequest("services/api/documents/signing", signerData, "POST");
+    return { signer: signerData.typedoc + signerData.doc, success: true };
+  } catch (error) {
+    if (error instanceof ApacuanaAPIError) {
+      throw error;
+    }
+    throw new Error(
+      `Fallo al agregar firmante en On-Boarding: ${error.message}`
+    );
   }
 };
 
+const addSignerOnPremise = async () =>
+  Promise.resolve({ signerId: "on-premise-signer-id", status: "added" });
+
 /**
- * Simula la adición de un firmante a un documento.
+ * Agrega un firmante a un documento, manejando diferentes tipos de integración.
  * @param {object} signerData - Datos del firmante a agregar.
  * @returns {Promise<object>} Objeto con el resultado de agregar el firmante.
  */
 export const addSigner = async (signerData) => {
-  console.log("-> Función 'addSigner' ejecutada.");
-  console.log('Parámetros recibidos para agregar firmante:', signerData);
+  if (
+    !signerData ||
+    typeof signerData !== "object" ||
+    Object.keys(signerData).length === 0
+  ) {
+    throw new ApacuanaAPIError(
+      "Los datos del firmante (signerData) son requeridos y deben ser un objeto no vacío.",
+      400,
+      "INVALID_PARAMETER"
+    );
+  }
 
-  if (!signerData || typeof signerData !== 'object') {
-    throw new Error('Datos de firmante son requeridos para addSigner.');
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return addSignerOnBoarding(signerData);
   }
 
-  try {
-    const response = await httpRequest(
-      '/docs/signers',
-      signerData,
-      'POST',
-    );
-    console.log(
-      'Respuesta del servidor simulada para agregar firmante:',
-      response,
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return addSignerOnPremise(signerData);
+  }
+
+  throw new ApacuanaAPIError(
+    `Tipo de integración no soportado: ${integrationType}`,
+    400,
+    "UNSUPPORTED_INTEGRATION_TYPE"
+  );
+};
+
+const getDocsOnPremise = async () => {
+  throw new ApacuanaAPIError(
+    "La obtención de documentos no está soportada para el tipo de integración: ONBOARDING",
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};
+
+const getDocsOnBoarding = async (data) => {
+  const { customerId } = getConfig();
+  if (!customerId) {
+    throw new ApacuanaAPIError(
+      "El 'customerId' no está configurado. Por favor, configure el SDK.",
+      400,
+      "CONFIGURATION_ERROR"
     );
-    if (!response.success) {
-      throw new ApacuanaAPIError(
-        response.message || 'Error desconocido al agregar firmante.',
-      );
-    }
-    return { signerId: response.id, status: response.message };
+  }
+
+  try {
+    const apiUrl = `services/api/documents/listcustomer?page=${data.page}&customerid=${customerId}&size=${data.size}&status=${data.status}`;
+
+    const response = await httpRequest(apiUrl, {}, "GET");
+    return response;
   } catch (error) {
-    throw new Error(`Fallo al agregar firmante: ${error.message}`);
+    if (error.name === "ApacuanaAPIError") {
+      throw error;
+    }
+    throw new ApacuanaAPIError(
+      `Fallo al obtener la lista de documentos (on-premise): ${error.message}`
+    );
   }
 };
+
+/**
+ * Obtiene una lista de documentos.
+ * @param {object} data - Objeto con los parámetros de paginación. Debe contener {page, size}.
+ * @returns {Promise<object>} Objeto con la lista de documentos.
+ */
+export const getDocs = async (data) => {
+  helpers.validateGetDocsData(data);
+
+  const { integrationType } = getConfig();
+
+  if (integrationType === INTEGRATION_TYPE.ONBOARDING) {
+    return getDocsOnBoarding(data);
+  }
+
+  if (integrationType === INTEGRATION_TYPE.ONPREMISE) {
+    return getDocsOnPremise();
+  }
+
+  throw new ApacuanaAPIError(
+    `La obtención de documentos no está soportada para un tipo de integración desconocido: ${integrationType}`,
+    501,
+    "NOT_IMPLEMENTED"
+  );
+};

package/src/api/users.js

@@ -55,6 +55,7 @@ const getCustomer = async () => {
     return {
       token: response.sessionid,
       userData: response.entry,
+      success: true,
     }; // Retorna el objeto de usuario directamente
   } catch (error) {
     // 4. Manejo de Errores

package/src/errors/index.js

@@ -9,6 +9,7 @@ export class ApacuanaAPIError extends Error {
     this.name = "ApacuanaAPIError";
     this.statusCode = statusCode;
     this.errorCode = errorCode;
+    this.success = false; // Añadir el atributo success con valor false
 
     // Mantener el stack trace correcto
     if (Error.captureStackTrace) {

package/src/index.js

@@ -1,9 +1,9 @@
-// src/index.js
 import { setConfig, getConfig } from "./config/index";
 import { initHttpClient, setAuthToken } from "./utils/httpClient";
 import getCustomer from "./api/users";
 import requestRevocation from "./api/revocations";
 import { getCertStatus } from "./api/certs";
+import { addSigner, getDocs } from "./api/signatures";
 
 const apacuana = {
   /**
@@ -62,6 +62,9 @@ const apacuana = {
   getConfig,
   requestRevocation,
   getCertStatus,
+  getCustomer,
+  addSigner,
+  getDocs,
 };
 
 export default apacuana;