@acontplus/ng-common 1.0.3 → 1.0.5

package/README.md

@@ -134,7 +134,7 @@ import {
 export class ReportsComponent {
   constructor(private reportFacade: ReportFacade) {}
 
-  // Ejemplo 1: Reporte simple de factura
+  // Ejemplo 1: Generar y abrir PDF automáticamente
   generateInvoiceReport(id: number, codEstab: string) {
     const reportOptions = ReportParamsBuilder.build(
       {
@@ -142,16 +142,18 @@ export class ReportsComponent {
         id,
         codEstab
       },
-      REPORT_FORMAT.PDF,
-      true // returnBlob
+      REPORT_FORMAT.PDF
     );
 
-    this.reportFacade.generate(reportOptions).subscribe(response => {
-      console.log('Reporte generado');
-    });
+    // Se abre automáticamente en nueva ventana (o descarga en navegadores legacy)
+    this.reportFacade.openPDF(reportOptions.data, reportOptions.useV1Api)
+      .subscribe({
+        next: () => console.log('Reporte generado'),
+        error: (err) => console.error('Error:', err)
+      });
   }
 
-  // Ejemplo 2: Reporte de ventas con parámetros personalizados
+  // Ejemplo 2: Generar Excel y descargar automáticamente
   generateSalesReport() {
     const reportOptions = ReportParamsBuilder.build(
       {
@@ -165,47 +167,54 @@ export class ReportsComponent {
       REPORT_FORMAT.EXCEL
     );
 
-    this.reportFacade.generate(reportOptions);
+    this.reportFacade.downloadExcel(reportOptions.data, reportOptions.useV1Api)
+      .subscribe();
   }
 
-  // Ejemplo 3: Reporte de inventario con múltiples parámetros
-  generateInventoryReport() {
+  // Ejemplo 3: Control total sobre el blob
+  generateCustomReport() {
     const reportOptions = ReportParamsBuilder.build(
       {
         codDoc: INVENTORY_CODE_REPORT.ARTICULO_PVP,
         tipo: 2,
         stockStatusCode: 1,
-        idTarifa: 3,
-        idMarca: 10,
-        fechaInicio: this.fromDate,
-        fechaFin: this.toDate,
-        // Cualquier parámetro adicional se incluye automáticamente
-        customParam: 'valor'
+        idTarifa: 3
       },
       REPORT_FORMAT.PDF
     );
 
-    this.reportFacade.generate(reportOptions);
+    this.reportFacade.generate(reportOptions)
+      .subscribe({
+        next: (response) => {
+          // Tienes control total del blob
+          const blob = response.body;
+          if (blob) {
+            // Hacer lo que quieras: enviar por WhatsApp, guardar, etc.
+            this.sendViaWhatsApp(blob);
+          }
+        }
+      });
   }
 
-  // Ejemplo 4: Reporte condicional
-  generateConditionalReport(useCustom: boolean) {
-    const reportCode = useCustom
-      ? SALE_CODE_REPORT.SRRC
-      : SALE_CODE_REPORT.SRR;
-
+  // Ejemplo 4: Usar métodos genéricos
+  quickPDFReport() {
     const reportOptions = ReportParamsBuilder.build(
-      {
-        codDoc: reportCode,
-        porcentajeRenta: 15,
-        porcentajeComision: 5,
-        fechaInicio: this.fromDate,
-        fechaFin: this.toDate
-      },
+      { codDoc: SALE_CODE_REPORT.SRR },
       REPORT_FORMAT.PDF
     );
 
-    this.reportFacade.generate(reportOptions);
+    // Abre automáticamente
+    this.reportFacade.open(reportOptions).subscribe();
+  }
+
+  quickExcelDownload() {
+    const reportOptions = ReportParamsBuilder.build(
+      { codDoc: INVENTORY_CODE_REPORT.RCD },
+      REPORT_FORMAT.EXCEL
+    );
+
+    // Descarga automáticamente
+    this.reportFacade.download(reportOptions).subscribe();
   }
 
   // Verificar tipos soportados
@@ -213,11 +222,6 @@ export class ReportsComponent {
     const types = ReportParamsBuilder.getSupportedDocumentTypes();
     console.log('Tipos soportados:', types);
   }
-
-  // Verificar si un tipo está soportado
-  isSupported(code: string) {
-    return ReportParamsBuilder.isDocumentTypeSupported(code);
-  }
 }
 ```
 

package/fesm2022/acontplus-ng-common.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, Injectable, signal, Input, Component } from '@angular/core';
+import { tap, Observable, throwError } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
-import { Observable, throwError } from 'rxjs';
 import * as i1 from '@angular/forms';
 import { FormBuilder, Validators, ReactiveFormsModule } from '@angular/forms';
 import { CommonModule } from '@angular/common';
@@ -168,9 +168,9 @@ var REPORT_FORMAT;
 })(REPORT_FORMAT || (REPORT_FORMAT = {}));
 
 const API_PATHS = {
-    WHATSAPP: '/api/common/whatsapp-cloud',
-    REPORTS: '/api/reports',
-    CONFIG: '/api/config',
+    WHATSAPP: 'common/whatsapp-cloud',
+    REPORTS: 'reports',
+    CONFIG: 'config',
 };
 const DOCUMENT_TYPES = {
     NORMAL: 'NORMAL',
@@ -184,40 +184,307 @@ const WHATSAPP_MESSAGING_PORT = new InjectionToken('WHATSAPP_MESSAGING_PORT');
 
 const PRINTER_PORT = new InjectionToken('PRINTER_PORT');
 
+/**
+ * Utilidades para manejo de archivos y respuestas HTTP
+ */
+class FileMapperUtil {
+    /**
+     * Extrae el nombre de archivo desde el header Content-Disposition
+     */
+    static extractFileName(response) {
+        const contentDisposition = response.headers?.get('content-disposition');
+        if (!contentDisposition) {
+            return this.generateDefaultFileName();
+        }
+        // Método más robusto para extraer filename
+        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
+        if (matches && matches[1]) {
+            let fileName = matches[1].replace(/['"]/g, '');
+            // Limpiar caracteres especiales
+            fileName = fileName.replaceAll('+', ' ').trim();
+            return fileName || this.generateDefaultFileName();
+        }
+        // Fallback: método simple
+        const simpleParse = contentDisposition.split('filename=')[1];
+        if (simpleParse) {
+            return simpleParse.replace(/['"]/g, '').trim() || this.generateDefaultFileName();
+        }
+        return this.generateDefaultFileName();
+    }
+    /**
+     * Crea un objeto File desde una respuesta HTTP
+     */
+    static fromResponse(response) {
+        const fileName = this.extractFileName(response);
+        const contentType = response.headers?.get('content-type') || 'application/octet-stream';
+        return new File([response.body], fileName, { type: contentType });
+    }
+    /**
+     * Descarga un archivo usando la API nativa del navegador
+     */
+    static downloadFile(blob, fileName) {
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        link.style.display = 'none';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        // Limpiar el objeto URL
+        URL.revokeObjectURL(url);
+    }
+    /**
+     * Abre un archivo en una nueva ventana (para PDFs)
+     */
+    static openFile(blob, fileName) {
+        const fileURL = URL.createObjectURL(blob);
+        window.open(fileURL, fileName);
+        // Limpiar URL después de un tiempo
+        setTimeout(() => URL.revokeObjectURL(fileURL), 1000);
+    }
+    /**
+     * Detecta si es un navegador legacy que requiere descarga forzada
+     */
+    static isLegacyBrowser() {
+        const userAgent = navigator.userAgent;
+        return !!(userAgent.match(/Edge/g) || userAgent.match(/.NET/g) || userAgent.match(/MSIE/g));
+    }
+    static generateDefaultFileName() {
+        const timestamp = Date.now();
+        return `document_${timestamp}.pdf`;
+    }
+}
+
+/**
+ * Facade para generación de reportes
+ *
+ * Proporciona una API de alto nivel para generar reportes con manejo automático de archivos.
+ * Todos los métodos devuelven Observables - el consumidor debe hacer subscribe().
+ *
+ * @example
+ * ```typescript
+ * // Control total del blob
+ * this.reportFacade.generate(options).subscribe(response => {
+ *   const blob = response.body;
+ *   // Procesar blob manualmente
+ * });
+ *
+ * // Descarga automática
+ * this.reportFacade.download(options).subscribe();
+ *
+ * // Abrir PDF automáticamente
+ * this.reportFacade.open(options).subscribe();
+ * ```
+ */
 class ReportFacade {
     reportPort = inject(REPORT_PORT);
-    // Método principal unificado
+    /**
+     * Genera un reporte y devuelve el Observable con el blob
+     *
+     * Este método proporciona control total sobre el blob generado.
+     * No realiza ninguna acción automática (descarga/apertura).
+     * Útil cuando necesitas procesar el blob manualmente (enviar por WhatsApp, guardar en servidor, etc.)
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @param options.data - Datos del reporte (usar ReportParamsBuilder.build())
+     * @param options.format - Formato del reporte: 'pdf' | 'excel' | 'word'
+     * @param options.useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable con la respuesta HTTP que contiene el blob
+     *
+     * @example
+     * ```typescript
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     *
+     * this.reportFacade.generate(options).subscribe({
+     *   next: (response) => {
+     *     const blob = response.body;
+     *     const fileName = FileMapperUtil.extractFileName(response);
+     *     // Procesar blob según necesidad
+     *   },
+     *   error: (err) => console.error('Error:', err)
+     * });
+     * ```
+     */
     generate(options) {
         return this.reportPort.generate(options);
     }
-    // Métodos de conveniencia para casos comunes
-    generatePDF(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un reporte y lo descarga automáticamente
+     *
+     * Extrae el nombre del archivo desde los headers HTTP y descarga el archivo automáticamente.
+     * Funciona para cualquier formato (PDF, Excel, Word).
+     * El Observable se completa después de iniciar la descarga.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * // Con formato dinámico
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: SALE_CODE_REPORT.FG },
+     *   this.selectedFormat // 'pdf' | 'excel' | 'word'
+     * );
+     * this.reportFacade.download(options).subscribe();
+     *
+     * // Con formato fijo
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: INVENTORY_CODE_REPORT.RCD },
+     *   'excel'
+     * );
+     * this.reportFacade.download(options).subscribe();
+     * ```
+     */
+    download(options) {
+        return this.reportPort.generate(options).pipe(tap((response) => {
+            const fileName = FileMapperUtil.extractFileName(response);
+            if (response.body) {
+                FileMapperUtil.downloadFile(response.body, fileName);
+            }
+        }));
+    }
+    /**
+     * Genera un reporte y lo abre en nueva ventana (o descarga en navegadores legacy)
+     *
+     * Comportamiento inteligente según el navegador:
+     * - Navegadores modernos: Abre el archivo en nueva ventana/pestaña
+     * - Navegadores legacy (IE, Edge antiguo): Descarga el archivo
+     *
+     * Ideal para PDFs que el usuario quiere visualizar inmediatamente.
+     * También funciona con Excel/Word pero la experiencia puede variar según el navegador.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param options - Opciones de generación del reporte
+     * @returns Observable que se completa después de abrir/descargar el archivo
+     *
+     * @example
+     * ```typescript
+     * // Abrir PDF
+     * const options = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     * this.reportFacade.open(options).subscribe();
+     *
+     * // Con formato dinámico
+     * const format = this.isPDF ? 'pdf' : 'excel';
+     * const options = ReportParamsBuilder.build({ codDoc: code }, format);
+     * this.reportFacade.open(options).subscribe();
+     * ```
+     */
+    open(options) {
+        return this.reportPort.generate(options).pipe(tap((response) => {
+            const fileName = FileMapperUtil.extractFileName(response);
+            if (response.body) {
+                if (FileMapperUtil.isLegacyBrowser()) {
+                    FileMapperUtil.downloadFile(response.body, fileName);
+                }
+                else {
+                    FileMapperUtil.openFile(response.body, fileName);
+                }
+            }
+        }));
+    }
+    /**
+     * Genera un PDF y lo abre automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y abrir PDFs.
+     * Equivalente a llamar open() con format: 'pdf'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de abrir el PDF
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: ELECTRONIC_DOCUMENT_CODE.FV, id: 123 },
+     *   'pdf'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.openPDF(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    openPDF(data, useV1Api = false) {
+        return this.open({
             data,
             format: 'pdf',
-            forceDownload,
+            useV1Api,
         });
     }
-    generateExcel(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un Excel y lo descarga automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y descargar archivos Excel.
+     * Equivalente a llamar download() con format: 'excel'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: SALE_CODE_REPORT.FG, fechaInicio: '2024-01-01' },
+     *   'excel'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.downloadExcel(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    downloadExcel(data, useV1Api = false) {
+        return this.download({
             data,
             format: 'excel',
-            forceDownload,
+            useV1Api,
         });
     }
-    generateWord(data, forceDownload = false) {
-        this.reportPort.generate({
+    /**
+     * Genera un Word y lo descarga automáticamente (shortcut)
+     *
+     * Método de conveniencia para el caso común de generar y descargar archivos Word.
+     * Equivalente a llamar download() con format: 'word'.
+     *
+     * @template T - Tipo de datos del reporte
+     * @param data - Datos del reporte (resultado de ReportParamsBuilder.build().data)
+     * @param useV1Api - Si debe usar la API v1 (por defecto false)
+     * @returns Observable que se completa después de iniciar la descarga
+     *
+     * @example
+     * ```typescript
+     * const reportOptions = ReportParamsBuilder.build(
+     *   { codDoc: CUSTOMER_CODE_REPORT.RCL },
+     *   'word'
+     * );
+     *
+     * // Forma corta
+     * this.reportFacade.downloadWord(
+     *   reportOptions.data,
+     *   reportOptions.useV1Api
+     * ).subscribe();
+     * ```
+     */
+    downloadWord(data, useV1Api = false) {
+        return this.download({
             data,
             format: 'word',
-            forceDownload,
-        });
-    }
-    // Método para generar y retornar blob
-    generateBlob(data, format = 'pdf') {
-        return this.reportPort.generate({
-            data,
-            format,
-            returnBlob: true,
+            useV1Api,
         });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportFacade, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
@@ -615,113 +882,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.6", ngImpor
         }] });
 
 /**
- * Utilidades para manejo de archivos y respuestas HTTP
+ * Adapter para generación de reportes
+ * Siempre devuelve Observable - el consumidor decide qué hacer con el blob
  */
-class FileMapperUtil {
-    /**
-     * Extrae el nombre de archivo desde el header Content-Disposition
-     */
-    static extractFileName(response) {
-        const contentDisposition = response.headers?.get('content-disposition');
-        if (!contentDisposition) {
-            return this.generateDefaultFileName();
-        }
-        // Método más robusto para extraer filename
-        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
-        if (matches && matches[1]) {
-            let fileName = matches[1].replace(/['"]/g, '');
-            // Limpiar caracteres especiales
-            fileName = fileName.replaceAll('+', ' ').trim();
-            return fileName || this.generateDefaultFileName();
-        }
-        // Fallback: método simple
-        const simpleParse = contentDisposition.split('filename=')[1];
-        if (simpleParse) {
-            return simpleParse.replace(/['"]/g, '').trim() || this.generateDefaultFileName();
-        }
-        return this.generateDefaultFileName();
-    }
-    /**
-     * Crea un objeto File desde una respuesta HTTP
-     */
-    static fromResponse(response) {
-        const fileName = this.extractFileName(response);
-        const contentType = response.headers?.get('content-type') || 'application/octet-stream';
-        return new File([response.body], fileName, { type: contentType });
-    }
-    /**
-     * Descarga un archivo usando la API nativa del navegador
-     */
-    static downloadFile(blob, fileName) {
-        const url = URL.createObjectURL(blob);
-        const link = document.createElement('a');
-        link.href = url;
-        link.download = fileName;
-        link.style.display = 'none';
-        document.body.appendChild(link);
-        link.click();
-        document.body.removeChild(link);
-        // Limpiar el objeto URL
-        URL.revokeObjectURL(url);
-    }
-    /**
-     * Abre un archivo en una nueva ventana (para PDFs)
-     */
-    static openFile(blob, fileName) {
-        const fileURL = URL.createObjectURL(blob);
-        window.open(fileURL, fileName);
-        // Limpiar URL después de un tiempo
-        setTimeout(() => URL.revokeObjectURL(fileURL), 1000);
-    }
-    /**
-     * Detecta si es un navegador legacy que requiere descarga forzada
-     */
-    static isLegacyBrowser() {
-        const userAgent = navigator.userAgent;
-        return !!(userAgent.match(/Edge/g) || userAgent.match(/.NET/g) || userAgent.match(/MSIE/g));
-    }
-    static generateDefaultFileName() {
-        const timestamp = Date.now();
-        return `document_${timestamp}.pdf`;
-    }
-}
-
 class ReportAdapter {
     http = inject(HttpClient);
     generate(options) {
-        const { data, format = 'pdf', useV1Api = false, forceDownload = false, returnBlob = false, } = options;
-        const reportVersionPath = useV1Api ? '/v1/' : '/v2/';
-        const fullPath = `${API_PATHS.REPORTS}${reportVersionPath}download`;
-        const requestOptions = {
+        const { data, useV1Api = false } = options;
+        const reportVersionPath = useV1Api ? '/reporte/download' : '/v2/reporte/download';
+        const fullPath = `${API_PATHS.REPORTS}${reportVersionPath}`;
+        return this.http.post(fullPath, data, {
             observe: 'response',
             responseType: 'blob',
-        };
-        if (returnBlob) {
-            return this.http.post(fullPath, data, requestOptions);
-        }
-        this.http.post(fullPath, data, requestOptions).subscribe({
-            next: (response) => this.saveFile(response, format, forceDownload),
-            error: (err) => {
-                console.error('Error al descargar el reporte:', err);
-            },
         });
-        return;
-    }
-    getFileName(response) {
-        return FileMapperUtil.extractFileName(response);
-    }
-    saveFile(response, format, forceDownload = false) {
-        const fileName = this.getFileName(response);
-        if (!response.body)
-            return;
-        if (format === 'pdf' && !forceDownload && !FileMapperUtil.isLegacyBrowser()) {
-            // Abrir PDF en nueva ventana para navegadores modernos
-            FileMapperUtil.openFile(response.body, fileName);
-        }
-        else {
-            // Descargar archivo (Excel, Word, o PDF forzado)
-            FileMapperUtil.downloadFile(response.body, fileName);
-        }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.6", ngImport: i0, type: ReportAdapter });