fpavon-ee-shared 1.0.0

package/dependency-injection/dependency-injection.ts

@@ -0,0 +1,56 @@
+import { ContainerBuilder } from 'node-dependency-injection';
+import { ExpedienteElectronicoSqlRepository } from '../expediente-electronico/infrastructure/repositories/expediente-electronico.sql.repository';
+import { ExpedienteElectronicoUseCase } from '../expediente-electronico/application/expediente-electronico.useCase';
+import { ExpedienteElectronicoController } from '../expediente-electronico/infrastructure/controller/expediente-electronico.controller';
+import { DocumentosUseCase } from '../documentos/application/documentos.useCase';
+import { NotificacionController } from '../notificaciones/infrastructure/notificacion.controller';
+import { FlujosController } from '../estados/infrastructure/controller/flujos.controller';
+import { FlujosUseCase } from '../estados/application/flujos.useCase';
+import { FlujosRepository } from '../estados/infrastructure/repositories/flujos.sql.repository';
+import { DocumentosFTPRepository } from '../documentos/infrastructure/repository/documentos.ftp.repository';
+import { FtpConnection } from '../infrastructure/fileServer/fileServer.basic-ftp';
+
+
+let container = new ContainerBuilder();
+
+/**
+ * Notificaciones
+ */
+container.register('EE.Notificaciones.infrastructure.NotificacionesController', NotificacionController);
+const notificacionCtrl = container.get('EE.Notificaciones.infrastructure.NotificacionesController');
+
+/**
+ * Flujos
+ */
+container.register('EE.Flujos.infrastructure.FlujosRepository', FlujosRepository);
+const flujosRepo = container.get('EE.Flujos.infrastructure.FlujosRepository');
+container.register('EE.Flujos.application.FlujosUseCase', FlujosUseCase).addArgument(flujosRepo);
+const flujosUseCase = container.get('EE.Flujos.application.FlujosUseCase');
+container.register('EE.Flujos.infrastructure.FlujosController', FlujosController).addArgument(flujosUseCase);
+const flujosController = container.get('EE.Flujos.infrastructure.FlujosController');
+
+
+container.register('EE.FTPConnection', FtpConnection);
+const ftp = container.get('EE.FTPConnection');
+
+/**
+ * Documentos
+*/
+container.register('EE.Documentos.infrastructure.DocumentosRepository', DocumentosFTPRepository).addArgument(ftp);
+const docRepo = container.get('EE.Documentos.infrastructure.DocumentosRepository')
+container.register('EE.Documentos.application.DocumentosUseCase', DocumentosUseCase).addArgument(docRepo);
+const docUseCase = container.get('EE.Documentos.application.DocumentosUseCase')
+
+/**
+ * Expediente Electronico
+ */
+
+container.register('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoSqlRepository', ExpedienteElectronicoSqlRepository);
+const expedienteRepo = container.get('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoSqlRepository');
+
+container.register('EE.ExpedienteElectronico.application.ExpedienteElectronicoUseCase', ExpedienteElectronicoUseCase).addArgument(expedienteRepo).addArgument(docRepo);
+const expedienteUseCase = container.get('EE.ExpedienteElectronico.application.ExpedienteElectronicoUseCase');
+
+container.register('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoController', ExpedienteElectronicoController).addArgument(expedienteUseCase).addArgument(notificacionCtrl)
+
+export default container;

package/digitalSignature/application/digitalSignature.useCase.ts

@@ -0,0 +1,171 @@
+const fs = require('fs');
+import { PDFDocument, rgb, StandardFonts } from 'pdf-lib';
+import * as crypto from 'crypto';
+import moment from 'moment';
+import PDFMerger from 'pdf-merger-js';
+import SignPDF from '../domain/SignPDF';
+import axios from 'axios';
+import path from "node:path";
+import FormData from 'form-data';
+
+
+export async function obtenerFirmasDocumento(uuid: string): Promise<any[]> {
+
+    try {
+        const response = await axios.get(`${process.env.URL_FIRMAS_SERVICE}/detalle-firmas/${uuid}`);
+        return response.data;  // Esto sería un array con las firmas y sus datos
+    } catch (error: any) {
+        if (error.response) {
+            console.error("Error obtenerFirmasDocumento: respuesta inválida del servidor");
+            if (error.response.data?.message == 'El documento no contiene firmas digitales') {
+                // devuelvo array con firmas vacías ya que el documento no tiene firmas                
+                return [];
+            }
+            console.error(error.response.data);
+            console.error(error.response.status);
+            console.error(error.response.headers);
+        } else if (error.request) {
+            console.error("Error obtenerFirmasDocumento: No se recibió respuesta del servicio");
+            console.error(error.request);
+        } else {
+            console.error("Error obtenerFirmasDocumento: Error al preparar la solicitud", error.message);
+        }
+        throw new Error(`Error obtenerFirmasDocumento => ${error}`);
+    }
+}
+
+export async function firmarDocumento(documento: Buffer, firma: any, usuario: any, clave:any): Promise<Buffer> {
+    
+    const bytes = await addSignPage(usuario);
+    // Crear un PDF con la firma digital y el documento original
+    var merger = new PDFMerger();
+    await merger.add(documento);
+    await merger.add(await Buffer.from(bytes))
+
+    const documentoFirmado = await merger.saveAsBuffer();
+    // const documentoFirmado = bytes;
+
+    // return documentoFirmado;
+    const pdfBuffer = new SignPDF(
+        documentoFirmado,
+        path.resolve(firma.path)
+      );
+    
+    const signedDocs = await pdfBuffer.signPDF(clave);
+    return signedDocs;
+}
+
+export async function firmarDocumento2(token:string, uuid:any, firma: any, clave:any, x1:any, y1:any, page:any): Promise<string> {
+    let form = new FormData;
+    console.log("UUID: ", uuid);
+
+    form.append('clave', clave);
+    form.append('certificado', fs.createReadStream(firma.path));
+    form.append('uuid', uuid);
+    form.append('x1', x1);
+    form.append('y1', y1);
+    form.append('page', page);
+    const headers = {
+        ...form.getHeaders(),
+        'Authorization': `Bearer ${token}`
+    };
+    try {
+        
+        const response = await axios.post(`${process.env.URL_FIRMAS_SERVICE}/firmar-documento`, form, {headers});
+        return response.data.uuid;
+    } catch (error:any) {
+        if (error.response) {
+            console.error("Error firmarDocumento2: La respuesta fue hecha y el servidor respondió con un código de estado que esta fuera del rango de 2xx");
+            console.error(error.response.data);
+            console.error(error.response.status);
+            console.error(error.response.headers);
+        } else if (error.request) {
+            console.error("Error firmarDocumento2: Es probable que esté caido el servicio de EE-Firmas. La petición fue hecha pero no se recibió respuesta `error.request` es una instancia de XMLHttpRequest en el navegador y una instancia de http.ClientRequest en node.js")
+            console.error(error.request);
+        } else {
+            // Algo paso al preparar la petición que lanzo un Error
+            console.error('Error firmarDocumento2: Algo paso al preparar la petición que lanzo un Error', error.message);
+        }
+        throw new Error(`Error firmarDocumento2=> ${error}`);
+    }
+}
+async function addSignPage(usuario:any){
+    const response = await axios.get(`http://serverfirmas.ccba.usr.bpba:6050/ListImg/SW3UIDbGetRecInfo.php?IDX_FIR=001%20000${usuario.documento}000%20%20%20%20%20%20&IDX_TYA=TIT&IDX_LOC=ONL&TIP_DOC1=000${usuario.documento}000`, { responseType: 'arraybuffer' });
+    const firmaElectronica = response.data;
+    // Crear un nuevo documento PDF con pdf-lib
+
+    const templatePdfBytes = fs.readFileSync('src/ee-shared/digitalSignature/infrastructure/template/marco.pdf');
+    const templatePdfDoc = await PDFDocument.load(templatePdfBytes);
+    // const pdfDoc = await PDFDocument.load(documento);
+    
+    const timesRomanFont = await templatePdfDoc.embedFont(StandardFonts.TimesRoman)
+
+    // Add a blank page to the document
+    const page = templatePdfDoc.getPage(0);
+    // Get the width and height of the page
+    const { width, height } = page.getSize()
+    // Draw a string of text toward the top of the page
+    const fontSize = 12
+
+    // const page = pdfDoc.addPage([600, 800]);
+    let y = (height - 4 * fontSize);
+    page.drawText(`Firmado electronicamente por: `, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    y -= fontSize + 5
+    page.drawText(`Afiliado: ${usuario.uid}`, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    y -= fontSize + 5
+    page.drawText(`Nombre completo: ${usuario.nombreCompleto}`, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    y -= fontSize + 5
+    page.drawText(`Cargo: ${usuario.cargo}`, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    y -= fontSize + 5
+    page.drawText(`Fecha: ${moment().locale('es').format('LLLL')}`, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    y -= fontSize + 5
+    page.drawText(`Firma electrónica: `, {
+        x: 50,
+        y,
+        size: fontSize,
+        font: timesRomanFont,
+        color: rgb(0, 0, 0),
+    });
+    const signatureImage = await templatePdfDoc.embedPng(firmaElectronica);
+    const { width: imgWidth, height: imgHeight } = signatureImage.scale(0.3); // Aquí puedes ajustar el escalamiento
+    
+    y -= imgHeight + 5
+    page.drawImage(signatureImage, {
+        x: 50,
+        y,
+        width: imgWidth,
+        height: imgHeight
+    });
+
+    return await templatePdfDoc.save();
+}

package/digitalSignature/domain/PDFArrayCustom.ts

@@ -0,0 +1,60 @@
+import { PDFArray, CharCodes } from "pdf-lib";
+
+/**
+ * Extends PDFArray class in order to make ByteRange look like this:
+ *  /ByteRange [0 /********** /********** /**********]
+ * Not this:
+ *  /ByteRange [ 0 /********** /********** /********** ]
+ *
+ * @see https://github.com/Hopding/pdf-lib/issues/112#issuecomment-569085380
+ * @author https://github.com/Hopding
+ */
+// @ts-ignore
+export default class PDFArrayCustom extends PDFArray {
+  static withContext(context) {
+    // @ts-ignore
+    return new PDFArrayCustom(context);
+  }
+
+  clone(context) {
+    // @ts-ignore
+    const clone = PDFArrayCustom.withContext(context || this.context);
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      // @ts-ignore
+      clone.push(this.array[idx]);
+    }
+    return clone;
+  }
+
+  toString() {
+    let arrayString = "[";
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      arrayString += this.get(idx).toString();
+      if (idx < len - 1) arrayString += " ";
+    }
+    arrayString += "]";
+    return arrayString;
+  }
+
+  sizeInBytes() {
+    let size = 2;
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      size += this.get(idx).sizeInBytes();
+      if (idx < len - 1) size += 1;
+    }
+    return size;
+  }
+
+  copyBytesInto(buffer, offset) {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.LeftSquareBracket;
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      offset += this.get(idx).copyBytesInto(buffer, offset);
+      if (idx < len - 1) buffer[offset++] = CharCodes.Space;
+    }
+    buffer[offset++] = CharCodes.RightSquareBracket;
+
+    return offset - initialOffset;
+  }
+}

package/digitalSignature/domain/SignPDF.ts

@@ -0,0 +1,112 @@
+import {
+  PDFDocument,
+  PDFName,
+  PDFNumber,
+  PDFHexString,
+  PDFString,
+} from "pdf-lib";
+import signer from "node-signpdf";
+
+
+import fs from "fs";
+
+import PDFArrayCustom from "./PDFArrayCustom";
+
+export default class SignPDF {
+  pdfDoc: any;
+  certificate: any;
+  constructor(pdfFile:any, certFile:any) {
+    this.pdfDoc = pdfFile;
+    this.certificate = fs.readFileSync(certFile);
+  }
+
+  /**
+   * @return Promise<Buffer>
+   */
+  async signPDF(clave:any) {
+    try {
+      let newPDF = await this._addPlaceholder();
+      newPDF = signer.sign(newPDF, this.certificate,{ passphrase: clave });
+      
+      return newPDF;
+    } catch (error) {
+      console.error("Error en la firma: ", error)
+      throw new Error("Contraseña invalida");
+      
+    }
+  }
+
+  /**
+   * @see https://github.com/Hopding/pdf-lib/issues/112#issuecomment-569085380
+   * @returns {Promise<Buffer>}
+   */
+  async _addPlaceholder() {
+    const loadedPdf = await PDFDocument.load(this.pdfDoc);
+    const ByteRange = PDFArrayCustom.withContext(loadedPdf.context);
+    const DEFAULT_BYTE_RANGE_PLACEHOLDER = '**********';
+    const SIGNATURE_LENGTH = 8192;
+    const pages = loadedPdf.getPages();
+
+    ByteRange.push(PDFNumber.of(0));
+    ByteRange.push(PDFName.of(DEFAULT_BYTE_RANGE_PLACEHOLDER));
+    ByteRange.push(PDFName.of(DEFAULT_BYTE_RANGE_PLACEHOLDER));
+    ByteRange.push(PDFName.of(DEFAULT_BYTE_RANGE_PLACEHOLDER));
+
+    const signatureDict = loadedPdf.context.obj({
+      Type: 'Sig',
+      Filter: 'Adobe.PPKLite',
+      SubFilter: 'adbe.pkcs7.detached',
+      ByteRange,
+      Contents: PDFHexString.of('A'.repeat(SIGNATURE_LENGTH)),
+      Reason: PDFString.of('Firma electrónica'),
+      M: PDFString.fromDate(new Date()),
+    });   
+
+
+
+    const signatureDictRef = loadedPdf.context.register(signatureDict);
+
+    const widgetDict = loadedPdf.context.obj({
+      Type: 'Annot',
+      Subtype: 'Widget',
+      FT: 'Sig',
+      Rect: [0, 0, 0, 0], // Signature rect size
+      V: signatureDictRef,
+      T: PDFString.of('test signature'),
+      F: 4,
+      P: pages[0].ref,
+    });
+
+    const widgetDictRef = loadedPdf.context.register(widgetDict);
+
+    // Add signature widget to the first page
+    pages[0].node.set(PDFName.of('Annots'), loadedPdf.context.obj([widgetDictRef]));
+
+    loadedPdf.catalog.set(
+      PDFName.of('AcroForm'),
+      loadedPdf.context.obj({
+        SigFlags: 3,
+        Fields: [widgetDictRef],
+      })
+    );
+
+    // Allows signatures on newer PDFs
+    // @see https://github.com/Hopding/pdf-lib/issues/541
+    const pdfBytes = await loadedPdf.save({ useObjectStreams: false });
+
+    return SignPDF.unit8ToBuffer(pdfBytes);
+  }
+
+  /**
+   * @param {Uint8Array} unit8
+   */
+  static unit8ToBuffer(unit8:any) {
+    let buf = Buffer.alloc(unit8.byteLength);
+    const view = new Uint8Array(unit8);
+
+    for (let i = 0; i < buf.length; ++i) {
+      buf[i] = view[i];
+    }
+    return buf;
+  }
+}

package/digitalSignature/infrastructure/routes/digitalSignature.routes.ts

@@ -0,0 +1,3 @@
+
+
+

package/dist/dependency-injection/dependency-injection.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_dependency_injection_1 = require("node-dependency-injection");
+const expediente_electronico_sql_repository_1 = require("../expediente-electronico/infrastructure/repositories/expediente-electronico.sql.repository");
+const expediente_electronico_useCase_1 = require("../expediente-electronico/application/expediente-electronico.useCase");
+const expediente_electronico_controller_1 = require("../expediente-electronico/infrastructure/controller/expediente-electronico.controller");
+const documentos_useCase_1 = require("../documentos/application/documentos.useCase");
+const notificacion_controller_1 = require("../notificaciones/infrastructure/notificacion.controller");
+const flujos_controller_1 = require("../estados/infrastructure/controller/flujos.controller");
+const flujos_useCase_1 = require("../estados/application/flujos.useCase");
+const flujos_sql_repository_1 = require("../estados/infrastructure/repositories/flujos.sql.repository");
+const documentos_ftp_repository_1 = require("../documentos/infrastructure/repository/documentos.ftp.repository");
+const fileServer_basic_ftp_1 = require("../infrastructure/fileServer/fileServer.basic-ftp");
+let container = new node_dependency_injection_1.ContainerBuilder();
+/**
+ * Notificaciones
+ */
+container.register('EE.Notificaciones.infrastructure.NotificacionesController', notificacion_controller_1.NotificacionController);
+const notificacionCtrl = container.get('EE.Notificaciones.infrastructure.NotificacionesController');
+/**
+ * Flujos
+ */
+container.register('EE.Flujos.infrastructure.FlujosRepository', flujos_sql_repository_1.FlujosRepository);
+const flujosRepo = container.get('EE.Flujos.infrastructure.FlujosRepository');
+container.register('EE.Flujos.application.FlujosUseCase', flujos_useCase_1.FlujosUseCase).addArgument(flujosRepo);
+const flujosUseCase = container.get('EE.Flujos.application.FlujosUseCase');
+container.register('EE.Flujos.infrastructure.FlujosController', flujos_controller_1.FlujosController).addArgument(flujosUseCase);
+const flujosController = container.get('EE.Flujos.infrastructure.FlujosController');
+container.register('EE.FTPConnection', fileServer_basic_ftp_1.FtpConnection);
+const ftp = container.get('EE.FTPConnection');
+/**
+ * Documentos
+*/
+container.register('EE.Documentos.infrastructure.DocumentosRepository', documentos_ftp_repository_1.DocumentosFTPRepository).addArgument(ftp);
+const docRepo = container.get('EE.Documentos.infrastructure.DocumentosRepository');
+container.register('EE.Documentos.application.DocumentosUseCase', documentos_useCase_1.DocumentosUseCase).addArgument(docRepo);
+const docUseCase = container.get('EE.Documentos.application.DocumentosUseCase');
+/**
+ * Expediente Electronico
+ */
+container.register('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoSqlRepository', expediente_electronico_sql_repository_1.ExpedienteElectronicoSqlRepository);
+const expedienteRepo = container.get('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoSqlRepository');
+container.register('EE.ExpedienteElectronico.application.ExpedienteElectronicoUseCase', expediente_electronico_useCase_1.ExpedienteElectronicoUseCase).addArgument(expedienteRepo).addArgument(docRepo);
+const expedienteUseCase = container.get('EE.ExpedienteElectronico.application.ExpedienteElectronicoUseCase');
+container.register('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoController', expediente_electronico_controller_1.ExpedienteElectronicoController).addArgument(expedienteUseCase).addArgument(notificacionCtrl);
+exports.default = container;

package/dist/digitalSignature/application/digitalSignature.useCase.js

@@ -0,0 +1,180 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firmarDocumento2 = exports.firmarDocumento = exports.obtenerFirmasDocumento = void 0;
+const fs = require('fs');
+const pdf_lib_1 = require("pdf-lib");
+const moment_1 = __importDefault(require("moment"));
+const pdf_merger_js_1 = __importDefault(require("pdf-merger-js"));
+const SignPDF_1 = __importDefault(require("../domain/SignPDF"));
+const axios_1 = __importDefault(require("axios"));
+const node_path_1 = __importDefault(require("node:path"));
+const form_data_1 = __importDefault(require("form-data"));
+function obtenerFirmasDocumento(uuid) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const response = yield axios_1.default.get(`${process.env.URL_FIRMAS_SERVICE}/detalle-firmas/${uuid}`);
+            return response.data; // Esto sería un array con las firmas y sus datos
+        }
+        catch (error) {
+            if (error.response) {
+                console.error("Error obtenerFirmasDocumento: respuesta inválida del servidor");
+                if (((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.message) == 'El documento no contiene firmas digitales') {
+                    // devuelvo array con firmas vacías ya que el documento no tiene firmas                
+                    return [];
+                }
+                console.error(error.response.data);
+                console.error(error.response.status);
+                console.error(error.response.headers);
+            }
+            else if (error.request) {
+                console.error("Error obtenerFirmasDocumento: No se recibió respuesta del servicio");
+                console.error(error.request);
+            }
+            else {
+                console.error("Error obtenerFirmasDocumento: Error al preparar la solicitud", error.message);
+            }
+            throw new Error(`Error obtenerFirmasDocumento => ${error}`);
+        }
+    });
+}
+exports.obtenerFirmasDocumento = obtenerFirmasDocumento;
+function firmarDocumento(documento, firma, usuario, clave) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bytes = yield addSignPage(usuario);
+        // Crear un PDF con la firma digital y el documento original
+        var merger = new pdf_merger_js_1.default();
+        yield merger.add(documento);
+        yield merger.add(yield Buffer.from(bytes));
+        const documentoFirmado = yield merger.saveAsBuffer();
+        // const documentoFirmado = bytes;
+        // return documentoFirmado;
+        const pdfBuffer = new SignPDF_1.default(documentoFirmado, node_path_1.default.resolve(firma.path));
+        const signedDocs = yield pdfBuffer.signPDF(clave);
+        return signedDocs;
+    });
+}
+exports.firmarDocumento = firmarDocumento;
+function firmarDocumento2(token, uuid, firma, clave, x1, y1, page) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let form = new form_data_1.default;
+        console.log("UUID: ", uuid);
+        form.append('clave', clave);
+        form.append('certificado', fs.createReadStream(firma.path));
+        form.append('uuid', uuid);
+        form.append('x1', x1);
+        form.append('y1', y1);
+        form.append('page', page);
+        const headers = Object.assign(Object.assign({}, form.getHeaders()), { 'Authorization': `Bearer ${token}` });
+        try {
+            const response = yield axios_1.default.post(`${process.env.URL_FIRMAS_SERVICE}/firmar-documento`, form, { headers });
+            return response.data.uuid;
+        }
+        catch (error) {
+            if (error.response) {
+                console.error("Error firmarDocumento2: La respuesta fue hecha y el servidor respondió con un código de estado que esta fuera del rango de 2xx");
+                console.error(error.response.data);
+                console.error(error.response.status);
+                console.error(error.response.headers);
+            }
+            else if (error.request) {
+                console.error("Error firmarDocumento2: Es probable que esté caido el servicio de EE-Firmas. La petición fue hecha pero no se recibió respuesta `error.request` es una instancia de XMLHttpRequest en el navegador y una instancia de http.ClientRequest en node.js");
+                console.error(error.request);
+            }
+            else {
+                // Algo paso al preparar la petición que lanzo un Error
+                console.error('Error firmarDocumento2: Algo paso al preparar la petición que lanzo un Error', error.message);
+            }
+            throw new Error(`Error firmarDocumento2=> ${error}`);
+        }
+    });
+}
+exports.firmarDocumento2 = firmarDocumento2;
+function addSignPage(usuario) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios_1.default.get(`http://serverfirmas.ccba.usr.bpba:6050/ListImg/SW3UIDbGetRecInfo.php?IDX_FIR=001%20000${usuario.documento}000%20%20%20%20%20%20&IDX_TYA=TIT&IDX_LOC=ONL&TIP_DOC1=000${usuario.documento}000`, { responseType: 'arraybuffer' });
+        const firmaElectronica = response.data;
+        // Crear un nuevo documento PDF con pdf-lib
+        const templatePdfBytes = fs.readFileSync('src/ee-shared/digitalSignature/infrastructure/template/marco.pdf');
+        const templatePdfDoc = yield pdf_lib_1.PDFDocument.load(templatePdfBytes);
+        // const pdfDoc = await PDFDocument.load(documento);
+        const timesRomanFont = yield templatePdfDoc.embedFont(pdf_lib_1.StandardFonts.TimesRoman);
+        // Add a blank page to the document
+        const page = templatePdfDoc.getPage(0);
+        // Get the width and height of the page
+        const { width, height } = page.getSize();
+        // Draw a string of text toward the top of the page
+        const fontSize = 12;
+        // const page = pdfDoc.addPage([600, 800]);
+        let y = (height - 4 * fontSize);
+        page.drawText(`Firmado electronicamente por: `, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        y -= fontSize + 5;
+        page.drawText(`Afiliado: ${usuario.uid}`, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        y -= fontSize + 5;
+        page.drawText(`Nombre completo: ${usuario.nombreCompleto}`, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        y -= fontSize + 5;
+        page.drawText(`Cargo: ${usuario.cargo}`, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        y -= fontSize + 5;
+        page.drawText(`Fecha: ${(0, moment_1.default)().locale('es').format('LLLL')}`, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        y -= fontSize + 5;
+        page.drawText(`Firma electrónica: `, {
+            x: 50,
+            y,
+            size: fontSize,
+            font: timesRomanFont,
+            color: (0, pdf_lib_1.rgb)(0, 0, 0),
+        });
+        const signatureImage = yield templatePdfDoc.embedPng(firmaElectronica);
+        const { width: imgWidth, height: imgHeight } = signatureImage.scale(0.3); // Aquí puedes ajustar el escalamiento
+        y -= imgHeight + 5;
+        page.drawImage(signatureImage, {
+            x: 50,
+            y,
+            width: imgWidth,
+            height: imgHeight
+        });
+        return yield templatePdfDoc.save();
+    });
+}