@sachin9822/reports-lib 0.0.211 → 0.0.213

package/src/lib/shared/export-generic.service.ts

@@ -0,0 +1,557 @@
+// export-generic.service.ts
+import { Injectable } from '@angular/core';
+import jsPDF from 'jspdf';
+import 'jspdf-autotable';
+import * as ExcelJS from 'exceljs';
+import * as FileSaver from 'file-saver';
+
+export interface ExportOptions {
+    currencyFields?: string[];
+    dateFields?: string[];
+    dateFieldFormats?: {
+        [field: string]: 'dd/MM/yyyy' | 'dd/MM/yyyy hh:mm a' | 'dd/MM/yyyy HH:mm' | string;
+    };
+    excludeFields?: string[];
+    groupByKey?: boolean;
+    specialDecimalFields?: {
+        [field: string]: number;
+    };
+}
+
+@Injectable({ providedIn: 'root' })
+export class GenericExportService {
+    private logoBase64?: string;
+    private readonly pdfFontSize = 10;
+    private readonly pdfLineHeight = 7;
+    private readonly pdfLeftMargin = 15;
+
+    constructor() {
+        this.loadImageAsBase64('assets/reports-lib/assets/images/XMLogo.png').then(base64 => {
+            this.logoBase64 = base64;
+        }).catch(() => {
+            console.warn('Logo image failed to load');
+        });
+    }
+
+    private loadImageAsBase64(imagePath: string): Promise<string> {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.crossOrigin = 'anonymous';
+            img.src = imagePath;
+            img.onload = () => {
+                const scale = 6;
+                const canvas = document.createElement('canvas');
+                canvas.width = img.width * scale;
+                canvas.height = img.height * scale;
+                const ctx = canvas.getContext('2d');
+                if (ctx) {
+                    ctx.scale(scale, scale);
+                    ctx.drawImage(img, 0, 0);
+                    resolve(canvas.toDataURL('image/png', 1.0));
+                } else {
+                    reject('Failed to get canvas context.');
+                }
+            };
+            img.onerror = () => reject('Failed to load image: ' + imagePath);
+        });
+    }
+
+    // ==================== PDF EXPORT ====================
+    async exportToPdf({ title, metadata, searchCriteria, columns, data, options = {} }: {
+        title: string;
+        metadata: [string, string][];
+        searchCriteria: [string, string][];
+        columns: any[];
+        data: any[] | Record<string, any[]>;
+        options?: ExportOptions;
+    }): Promise<void> {
+        const doc = new jsPDF({ orientation: 'landscape', unit: 'mm', format: [400, 210] });
+        const pageWidth = doc.internal.pageSize.width;
+        const pageHeight = doc.internal.pageSize.height;
+        const marginLeft = 15;
+        const headers = ['Sr No', ...columns.map(c => c.headerName || c.field)];
+        let rows: any[][] = [];
+
+        if (options.groupByKey && !Array.isArray(data)) {
+            for (const [group, items] of Object.entries(data)) {
+                rows.push([{ content: group, colSpan: headers.length, styles: { halign: 'left', fontStyle: 'bold' } }]);
+                rows.push(...this.prepareTableRows(items, columns, options));
+            }
+        } else {
+            rows = this.prepareTableRows(data as any[], columns, options);
+        }
+
+        // Add logo at top left if available
+        if (this.logoBase64) {
+            doc.addImage(this.logoBase64, 'PNG', 15, 10, 38.4, 17.5);
+        }
+
+        // Title
+        doc.setFontSize(15);
+        doc.setFont('helvetica', 'bold');
+        doc.text(title, doc.internal.pageSize.width / 2, 18, { align: 'center' });
+
+        // Metadata
+        let currentY = 32;
+        doc.setFontSize(this.pdfFontSize);
+        metadata.forEach(([label, value], i) => {
+            const y = currentY + i * this.pdfLineHeight;
+            doc.setFont('helvetica', 'bold');
+            const labelWithColon = label + ' :';
+            doc.text(labelWithColon, this.pdfLeftMargin, y);
+            const labelWidth = doc.getTextWidth(labelWithColon + ' ');
+            doc.setFont('helvetica', 'normal');
+            doc.text(value, this.pdfLeftMargin + labelWidth, y);
+        });
+
+        currentY += metadata.length * this.pdfLineHeight + 5;
+
+        // --- draw search criteria heading ---
+        doc.setFont('helvetica', 'bold');
+        doc.text('Search Criteria:-', marginLeft, currentY);
+        currentY += 8;
+
+        const rowHeightPerLine = 6;
+        const minGap = 2; // gap between key and value
+        const betweenColumnsGap = 15; // gap between left and right columns (you can tune this)
+        const pageContentWidth = doc.internal.pageSize.width - 2 * marginLeft;
+
+        // --- helper function to measure total width of a key-value pair ---
+        const measurePairWidth = (key: string, value: string): number => {
+            doc.setFont('helvetica', 'bold');
+            const keyWidth = doc.getTextWidth(key + ' ');
+            doc.setFont('helvetica', 'normal');
+            const valueWidth = doc.getTextWidth(value);
+            return keyWidth + minGap + valueWidth;
+        };
+
+        // --- calculate max width of left column pairs dynamically ---
+        let maxLeftPairWidth = 0;
+        for (let i = 0; i < searchCriteria.length; i += 2) {
+            if (searchCriteria[i]) {
+                const [key, value] = searchCriteria[i];
+                const width = measurePairWidth(key, value);
+                if (width > maxLeftPairWidth) maxLeftPairWidth = width;
+            }
+        }
+
+        // --- compute where right column should start ---
+        const leftColumnStart = marginLeft;
+        const rightColumnStart = leftColumnStart + maxLeftPairWidth + betweenColumnsGap;
+
+        // --- print search criteria dynamically ---
+        for (let i = 0; i < searchCriteria.length; i += 2) {
+            let maxLineCount = 1;
+
+            // Left column
+            if (searchCriteria[i]) {
+                const [key, value] = searchCriteria[i];
+                doc.setFont('helvetica', 'bold');
+                doc.text(key, leftColumnStart, currentY);
+
+                doc.setFont('helvetica', 'normal');
+                const keyWidth = doc.getTextWidth(key + ' ');
+                const valueX = leftColumnStart + keyWidth + minGap;
+                doc.text(value, valueX, currentY);
+            }
+
+            // Right column
+            if (searchCriteria[i + 1]) {
+                const [key, value] = searchCriteria[i + 1];
+                doc.setFont('helvetica', 'bold');
+                doc.text(key, rightColumnStart, currentY);
+
+                doc.setFont('helvetica', 'normal');
+                const keyWidth = doc.getTextWidth(key + ' ');
+                const valueX = rightColumnStart + keyWidth + minGap;
+                doc.text(value, valueX, currentY);
+            }
+
+            currentY += rowHeightPerLine;
+        }
+
+        // Table styling
+        const columnStyles: { [key: number]: any } = {};
+        headers.forEach((_, i) => columnStyles[i] = { cellWidth: 'auto' });
+
+        doc.autoTable({
+            head: [headers],
+            body: rows,
+            startY: currentY,
+            theme: 'grid',
+            didParseCell: function (data) {
+
+                // Check if this row contains 'Total'
+                const rowValues = data.row.cells;
+
+                const isTotalRow = Object.values(rowValues).some(
+                    (cell: any) => cell.raw === 'Total'
+                );
+
+                if (isTotalRow) {
+                    data.cell.styles.fontStyle = 'bold';
+                    data.cell.styles.fontSize = 10; 
+                }
+            },
+            headStyles: {
+                fillColor: [220, 220, 220],
+                textColor: 0,
+                fontStyle: 'bold',
+                fontSize: 9,
+                halign: 'center'
+            },
+            bodyStyles: {
+                fontSize: 8,
+                fillColor: [255, 255, 255],
+                textColor: [0, 0, 0]
+            },
+            styles: {
+                cellPadding: 2,
+                overflow: 'linebreak',
+                minCellHeight: 6
+            },
+            columnStyles
+        });
+
+        const pageCount = (doc as any).internal.getNumberOfPages();
+        for (let i = 1; i <= pageCount; i++) {
+            doc.setFont("helvetica", "bold");
+            doc.setPage(i);
+            doc.setFontSize(9);
+            doc.setTextColor(100);
+
+            const footerY = pageHeight - 6;
+
+            doc.text(
+                `Page ${i} of ${pageCount}`,
+                pageWidth - 15,
+                footerY,
+                { align: 'right' }
+            );
+        }
+
+        doc.save(title.replace(/\s/g, '-') + '.pdf');
+    }
+
+    // ========== EXCEL EXPORT ==========
+    async exportToExcel({
+        title,
+        metadata,
+        searchCriteria,
+        columns,
+        data,
+        options = {}
+    }: {
+        title: string;
+        metadata: [string, string][];
+        searchCriteria: [string, string][];
+        columns: any[];
+        data: any[] | Record<string, any[]>;
+        options?: ExportOptions;
+    }): Promise<void> {
+        const workbook = new ExcelJS.Workbook();
+        const worksheet = workbook.addWorksheet(title);
+
+        // Pre-calc
+        const headerLabels = ['Sr No', ...columns.map(col => col.headerName || col.field)];
+        const totalCols = headerLabels.length;
+        const titleStartCol = 4; // Title in 4th Cell
+        const titleColLetter = String.fromCharCode(64 + titleStartCol);
+        const titleMergeEnd = String.fromCharCode(64 + totalCols);
+
+        // --- Add logo in A1:C3, and make those cells tall
+        if (this.logoBase64) {
+            const base64Data = this.logoBase64.replace(/^data:image\/\w+;base64,/, '');
+            const imageId = workbook.addImage({
+                base64: base64Data,
+                extension: 'png',
+            });
+            worksheet.addImage(imageId, {
+                tl: { col: 0, row: 0 },
+                ext: { width: 145, height: 66 }
+            });
+            // Optionally, make rows 1-3 taller to fully display logo
+            worksheet.getRow(1).height = 24;
+            worksheet.getRow(2).height = 22;
+            worksheet.getRow(3).height = 22;
+        }
+
+        // --- Title in D1 merged up to end
+        worksheet.mergeCells(`${titleColLetter}1:${titleMergeEnd}1`);
+        const titleCell = worksheet.getRow(1).getCell(titleStartCol);
+        titleCell.value = title;
+        titleCell.font = { bold: true, size: 16 };
+        titleCell.alignment = { vertical: 'middle', horizontal: 'left' };
+
+        // --- Leave A2:C3 empty (for image), place metadata starting at row 4
+        let metaRowStart = 4;
+        metadata.forEach(([label, value], idx) => {
+            const row = worksheet.getRow(metaRowStart + idx);
+            row.getCell(1).value = {
+                richText: [
+                    { text: `${label} : `, font: { bold: true } },
+                    { text: value ?? '', font: { bold: false } }
+                ]
+            };
+            worksheet.mergeCells(`A${row.number}:${titleMergeEnd}${row.number}`);
+        });
+
+        let currentRow = metaRowStart + metadata.length;
+
+        worksheet.getRow(++currentRow).height = 6; // Blank for readability
+        currentRow++;
+
+        worksheet.mergeCells(currentRow, 1, currentRow, 6);
+        worksheet.getCell(currentRow, 1).value = 'Search Criteria:-';
+        worksheet.getCell(currentRow, 1).font = { bold: true };
+        currentRow += 2;
+
+        for (let i = 0; i < searchCriteria.length; i += 2) {
+            const left = searchCriteria[i];
+            const right = searchCriteria[i + 1]; // may be undefined
+            const row = worksheet.getRow(currentRow++);
+
+            // Left cell
+            worksheet.mergeCells(row.number, 1, row.number, 3);
+            row.getCell(1).value = {
+                richText: [
+                    { text: (left?.[0] ?? '') + ' ', font: { bold: true } },
+                    { text: left?.[1] ?? '' }
+                ]
+            };
+            row.getCell(1).alignment = { wrapText: true, vertical: 'middle' };
+
+            // Right cell (only if present)
+            if (right) {
+                worksheet.mergeCells(row.number, 4, row.number, 6);
+                row.getCell(4).value = {
+                    richText: [
+                        { text: (right?.[0] ?? '') + ' ', font: { bold: true } },
+                        { text: right?.[1] ?? '' }
+                    ]
+                };
+                row.getCell(4).alignment = { wrapText: true, vertical: 'middle' };
+            }
+        }
+        currentRow++;
+
+        // Add headers and rest as before...
+        const headerRow = worksheet.getRow(currentRow++);
+        headerLabels.forEach((header, i) => {
+            const cell = headerRow.getCell(i + 1);
+            cell.value = header;
+            cell.font = { bold: true };
+            cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'D9D9D9' } };
+            cell.alignment = { vertical: 'middle', horizontal: 'center' };
+            cell.border = {
+                top: { style: 'thin' },
+                bottom: { style: 'thin' },
+                left: { style: 'thin' },
+                right: { style: 'thin' }
+            };
+        });
+
+        // Data rows (handle grouping if present)
+        let rowIdx = currentRow;
+        if (options.groupByKey && !Array.isArray(data)) {
+            for (const [group, items] of Object.entries(data)) {
+                // Group header: bold, merged row
+                const groupRow = worksheet.getRow(rowIdx++);
+                groupRow.getCell(1).value = group;
+                groupRow.font = { bold: true };
+                worksheet.mergeCells(`A${groupRow.number}:${titleMergeEnd}${groupRow.number}`);
+
+                // Data rows
+                this.prepareTableRows(items, columns, options).forEach(rowData => {
+                    const dataRow = worksheet.getRow(rowIdx++);
+                    rowData.forEach((cellVal, cIdx) => {
+                        const cell = dataRow.getCell(cIdx + 1);
+                        cell.value = cellVal;
+                        cell.border = {
+                            top: { style: 'thin' }, bottom: { style: 'thin' },
+                            left: { style: 'thin' }, right: { style: 'thin' }
+                        };
+                    });
+                });
+            }
+        } else {
+            this.prepareTableRows(data as any[], columns, options).forEach(rowData => {
+                const dataRow = worksheet.getRow(rowIdx++);
+                rowData.forEach((cellVal, cIdx) => {
+                    const cell = dataRow.getCell(cIdx + 1);
+                    cell.value = cellVal;
+                    cell.border = {
+                        top: { style: 'thin' }, bottom: { style: 'thin' },
+                        left: { style: 'thin' }, right: { style: 'thin' }
+                    };
+                });
+            });
+        }
+
+        // --- Auto column widths
+        for (let i = 1; i <= totalCols; i++) {
+            let maxLength = 10; // minimum width
+            worksheet.eachRow({ includeEmpty: true }, (row) => {
+                const cell = row.getCell(i);
+                if (cell.isMerged) return;
+                let cellValue = '';
+                if (cell.value == null) {
+                    cellValue = '';
+                } else if (typeof cell.value === 'object' && 'richText' in cell.value) {
+                    cellValue = cell.value.richText.map(rt => rt.text).join('');
+                } else {
+                    cellValue = cell.value.toString();
+                }
+                maxLength = Math.max(maxLength, cellValue.length);
+            });
+            // cap max width (so branch names don't explode sheet)
+            const adjustedWidth = Math.min(maxLength, 50);
+            worksheet.getColumn(i).width = adjustedWidth;
+        }
+
+        // --- Save workbook
+        const buffer = await workbook.xlsx.writeBuffer();
+        FileSaver.saveAs(
+            new Blob([buffer], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }),
+            title.replace(/\s/g, '-') + '.xlsx'
+        );
+    }
+
+
+    // ========== CSV EXPORT ==========
+    exportToCsv({
+        title,
+        metadata,
+        searchCriteria,
+        columns,
+        data,
+        options = {}
+    }: {
+        title: string;
+        metadata: [string, string][];
+        searchCriteria: [string, string][];
+        columns: any[];
+        data: any[] | Record<string, any[]>;
+        options?: ExportOptions;
+    }): void {
+        const headers = ['Sr No', ...columns.map(c => c.headerName || c.field)];
+        const metaLines = metadata.map(([lbl, val]) => `${lbl}: ${val}`);
+        let csv = [title, ...metaLines, ''];
+
+        //=======================================================
+        csv.push('Search Criteria:-');
+
+        const maxLeftLength = Math.max(...searchCriteria.map(([k, v]) => (k + ' ' + v).length));
+
+        for (let i = 0; i < searchCriteria.length; i += 2) {
+            const left = searchCriteria[i];
+            const right = searchCriteria[i + 1];
+
+            const leftText = left ? `${left[0]} ${left[1]}`.padEnd(maxLeftLength + 5, ' ') : '';
+            const rightText = right ? `${right[0]} ${right[1]}` : '';
+
+            csv.push(`"${leftText}${rightText}"`); // wrap in quotes for single CSV cell
+        }
+
+        csv.push(''); // blank line after criteria
+
+        // --- Headers ---
+        csv.push(headers.join(','));
+        //========================================================
+
+        if (options.groupByKey && !Array.isArray(data)) {
+            for (const [group, items] of Object.entries(data)) {
+                csv.push(group);
+                this.prepareTableRows(items, columns, options).forEach(row => {
+                    csv.push(row.map(val => `"${val}"`).join(','));
+                });
+            }
+        } else {
+            this.prepareTableRows(data as any[], columns, options).forEach(row => {
+                csv.push(row.map(val => `"${val}"`).join(','));
+            });
+        }
+
+        // Download
+        const blob = new Blob([csv.join('\n')], { type: 'text/csv' });
+        FileSaver.saveAs(blob, title.replace(/\s/g, '-') + '.csv');
+    }
+
+    // ================= HELPER: TABLE ROW PREPARATION =================
+    private prepareTableRows(data: any[], columns: any[], options: ExportOptions = {}): any[][] {
+        const {
+            excludeFields = [],
+            currencyFields = [],
+            dateFields = [],
+            dateFieldFormats = {},
+            specialDecimalFields = {}
+        } = options;
+
+        const filtered = columns.filter(c =>
+            c.field && !excludeFields.some(f => c.field.toLowerCase().includes(f))
+        );
+
+        return data.map((row, idx) => ([
+            idx + 1,
+            ...filtered.map(col => {
+                let value = row[col.field];
+
+                // Format date fields with custom formats if specified
+                if (col.field && (dateFields.includes(col.field) || col.field in dateFieldFormats)) {
+                    const format = dateFieldFormats[col.field] || 'dd/MM/yyyy';
+                    value = this.formatDateByFormat(value, format);
+                }
+                // Format special decimal fields with specific decimals
+                else if (col.field && col.field in specialDecimalFields && value != null) {
+                    const decimals = specialDecimalFields[col.field];
+                    value = parseFloat(value).toFixed(decimals);
+                }
+                // Format regular currency fields with 3 decimals
+                else if (col.field && currencyFields.includes(col.field) && value != null) {
+                    value = parseFloat(value).toFixed(3);
+                }
+
+                return value ?? '';
+            })
+        ]));
+    }
+
+    private formatDateByFormat(val: any, format: string): string {
+        // Helper to pad single digits
+        const pad = (n: number) => n.toString().padStart(2, '0');
+
+        // Parse date for "DD/MM/YYYY hh:mm AM/PM" format manually
+        if (typeof val === 'string' && /^\d{2}\/\d{2}\/\d{4} \d{2}:\d{2} [AP]M$/.test(val)) {
+            const parts = val.match(/^(\d{2})\/(\d{2})\/(\d{4}) (\d{2}):(\d{2}) ([AP]M)$/);
+            if (!parts) return '';
+            let [, dd, mm, yyyy, hh, min, ampm] = parts;
+            let hours = parseInt(hh, 10);
+            if (ampm === 'PM' && hours !== 12) hours += 12;
+            if (ampm === 'AM' && hours === 12) hours = 0;
+            val = new Date(parseInt(yyyy, 10), parseInt(mm, 10) - 1, parseInt(dd, 10), hours, parseInt(min, 10));
+        } else {
+            val = new Date(val);
+        }
+
+        if (isNaN(val.getTime())) return '';
+
+        const dt = val;
+
+        switch (format) {
+            case 'dd/MM/yyyy hh:mm a': { // 11/07/2025 10:56 PM
+                let hours12 = dt.getHours() % 12 || 12;
+                let ampm = dt.getHours() >= 12 ? 'PM' : 'AM';
+                return `${pad(dt.getDate())}/${pad(dt.getMonth() + 1)}/${dt.getFullYear()} ${pad(hours12)}:${pad(dt.getMinutes())} ${ampm}`;
+            }
+            case 'dd/MM/yyyy HH:mm': { // 28/07/2025 13:08
+                return `${pad(dt.getDate())}/${pad(dt.getMonth() + 1)}/${dt.getFullYear()} ${pad(dt.getHours())}:${pad(dt.getMinutes())}`;
+            }
+            case 'dd/MM/yyyy': { // 28/07/2025
+                return `${pad(dt.getDate())}/${pad(dt.getMonth() + 1)}/${dt.getFullYear()}`;
+            }
+            default:
+                return dt.toLocaleString();
+        }
+    }
+
+}

package/src/lib/shared/export.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ExportService } from './export.service';
+
+describe('ExportService', () => {
+  let service: ExportService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ExportService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});