@sachin9822/reports-lib 0.0.211 → 0.0.213

package/src/lib/components/accounting-report/accounting-report.component.ts

@@ -0,0 +1,738 @@
+import { Component, OnInit, ViewEncapsulation } from '@angular/core';
+import { AccountingReportModel } from '../../models/accounting-report/accounting-report-model';
+import { ColDef, ColumnApi, GridApi, GridReadyEvent } from 'ag-grid-community';
+import { ReportService } from '../../services/report.service';
+import { ExportService } from '../../shared/export.service';
+import { formatDate } from '@angular/common';
+import { ComponentLoadingStates } from '../../models/component-loading-states';
+import { AccountingReportBranchGroup } from '../../models/accounting-report/accounting-report-branch-group';
+import jsPDF from 'jspdf';
+import 'jspdf-autotable';
+import * as ExcelJS from 'exceljs';
+import * as FileSaver from 'file-saver';
+
+declare module 'jspdf' {
+  interface jsPDF {
+    autoTable: (options: any) => jsPDF;
+  }
+}
+
+export interface AccountingReportRequest {
+  startDate: string;
+  endDate: string;
+  sendCountryCode: string;
+  recvCountryCode: string;
+  businessPartnerCorrelationID: string;
+  transactionStatus: string;
+  payoutCurrency: string;
+  transactionType: string;
+  branchCode: string;
+  companyCode: string;
+}
+
+@Component({
+  selector: 'lib-accounting-report',
+  templateUrl: './accounting-report.component.html',
+  styleUrls: ['./accounting-report.component.scss'],
+})
+export class AccountingReportComponent implements OnInit {
+
+  ReportName: string = "Accounting";
+  reportUser: any;
+  reportTime: any;
+  reportPeriod: any;
+  branchNameAndCode: any;
+  subGroupColumn: any;
+  ComponentLoadingState = ComponentLoadingStates;
+  loadingState: ComponentLoadingStates = ComponentLoadingStates.Complete;
+  noDataFound: boolean = false;
+
+  leftData: Record<string, string>;
+  rightData: Record<string, string>;
+  searchCriteria: [string, string][];
+
+  searchText: string = '';
+  rowData = [];
+  accountingReportModel: AccountingReportModel;
+  pageSize: number = 15;
+
+  selectedExportOption: string = 'excel';
+  exportFormats = [{ formatName: "Excel", code: 'excel' }, { formatName: "PDF", code: 'pdf' }, { formatName: "CSV", code: 'csv' }]
+  isFormValid: boolean = false;
+
+  defaultColDef: ColDef = {
+    resizable: true,
+    sortable: true,
+    filter: true,
+    minWidth: 40,
+    suppressSizeToFit: false,
+    cellStyle: { userSelect: 'text', 'line-height': '1.2', 'white-space': 'normal', 'word-break': 'normal', 'overflow-wrap': 'break-word' },
+
+    //  Header wrapping
+    wrapHeaderText: true,
+    autoHeaderHeight: true,
+
+    //  Cell wrapping
+    wrapText: true,
+    autoHeight: true
+  };
+
+  columnDefs: ColDef[] = [
+    { headerName: 'BusinessDate', field: 'businessDate', tooltipField: 'businessDate' },
+    { headerName: 'TxnDate&Time', field: 'transactionDateAndTime', tooltipField: 'transactionDateAndTime', minWidth: 110, },
+    { headerName: 'Transaction Number', field: 'transactionNumber', tooltipField: 'transactionNumber' },
+    { headerName: 'SendClient', field: 'sendClient', tooltipField: 'sendClient' },
+    { headerName: 'Principle SendClient (If Applicable)', field: 'principleSendClient', tooltipField: 'principleSendClient', width: 90, minWidth: 80, maxWidth: 110 },
+    { headerName: 'ReceiveClient', field: 'receiveClient', tooltipField: 'receiveClient' },
+    { headerName: 'Principle ReceiveClient (If Applicable)', field: 'principleReceiveClient', tooltipField: 'principleReceiveClient', width: 100, minWidth: 90, maxWidth: 120 },
+    { headerName: 'ReceiveCcy', field: 'receiveCurrency', tooltipField: 'receiveCurrency' },
+    { headerName: 'AmountPaid', field: 'amountPaid', tooltipField: 'amountPaid', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'SendCcy', field: 'sendCurrency', tooltipField: 'sendCurrency', },
+    { headerName: 'ServiceFee', field: 'serviceFee', tooltipField: 'serviceFee', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'Tax', field: 'tax', tooltipField: 'tax', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'PrincipleSend Amount', field: 'principleSendAmount', tooltipField: 'principleSendAmount', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'Transaction Status', field: 'transactionStatus', tooltipField: 'transactionStatus' },
+    { headerName: 'SettlementCcy', field: 'settlementCurrency', tooltipField: 'settlementCurrency', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'ClientSettl (in SCcy)', field: 'clientSettlementInSCcy', tooltipField: 'clientSettlementInSCcy', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'ClientSettl (in USD)', field: 'clientSettlementInUSD', tooltipField: 'clientSettlementInUSD', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'ShareType', field: 'shareType', tooltipField: 'shareType' },
+    { headerName: 'ShareValue', field: 'shareValue', tooltipField: 'shareValue', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'Send/Receive FeeCcy', field: 'sendReceiveFeeCcy', tooltipField: 'sendReceiveFeeCcy' },
+    { headerName: 'ShareAmt (in USD)', field: 'shareAmountInUSD', tooltipField: 'shareAmountInUSD', cellClass: 'ag-right-aligned-cell' },
+    { headerName: 'Settlement Rate', field: 'settlementRate', tooltipField: 'settlementRate', cellClass: 'ag-right-aligned-cell' },
+  ];
+
+
+  gridApis: GridApi[] = [];
+  gridColumnApis: ColumnApi[] = [];
+
+  paginationArray: any[];
+  ezremitUser: boolean = false;
+  originalGroupEntries: AccountingReportBranchGroup[] = [];
+
+  constructor(private reportService: ReportService, private exportService: ExportService) { }
+
+  ngOnInit(): void {
+    const ezremitusername = sessionStorage.getItem('ezremitusername');
+    if (ezremitusername) {
+      this.ezremitUser = true;
+    }
+  }
+
+  public getAccountingReport(request?: AccountingReportRequest) {
+    this.loadingState = ComponentLoadingStates.Loading;
+    this.accountingReportModel = undefined;
+    this.branchNameAndCode = undefined;
+    this.subGroupColumn = undefined;
+    const finalReq = request;
+
+    this.reportService.getAccountingReport(finalReq).subscribe(data => {
+      this.accountingReportModel = data;
+      this.loadingState = ComponentLoadingStates.Complete;
+      this.noDataFound = Object.keys(this.accountingReportModel.accountingReportByBranchGroups).length == 0 ? true : false;
+      const branchCount = this.accountingReportModel.accountingReportByBranchGroups.length;
+      this.paginationArray = new Array(branchCount * 2).fill(15);
+
+      this.reportUser = this.accountingReportModel.reportUser;
+      this.reportTime = formatDate(new Date(), 'dd/MM/yyyy hh:mm a', 'en-US');
+      this.reportPeriod = `${formatDate(finalReq.startDate, 'dd/MM/yyyy', 'en-US')} - ${formatDate(finalReq.endDate, 'dd/MM/yyyy', 'en-US')}`;
+
+      this.leftData = {
+        'Report Period': `${this.reportPeriod}`,
+      }
+
+      this.rightData = {
+        'Report User & Time': `${this.reportUser} @ ${this.reportTime}`,
+      }
+
+      // Deep copy to preserve original data for search
+      this.originalGroupEntries = this.accountingReportModel.accountingReportByBranchGroups.map(group => ({
+        ...group,
+        sendTransactions: {
+          ...group.sendTransactions,
+          entries: [...group.sendTransactions.entries]
+        },
+        receiveTransactions: {
+          ...group.receiveTransactions,
+          entries: [...group.receiveTransactions.entries]
+        }
+      }));
+
+
+    }, error => {
+      console.log(error);
+    });
+  }
+
+  async handleExport(option: string) {
+    this.selectedExportOption = option;
+    switch (this.selectedExportOption) {
+      case 'excel':
+        this.exportToExcel();
+        break;
+      case 'pdf':
+        this.exportToPdf();
+        break;
+      case 'csv':
+        this.exportToCsv();
+        break;
+      default:
+        alert('Please select an export format.');
+    }
+  }
+
+  onSearch(text: string) {
+    const normalize = (str: any): string =>
+      str?.toString()
+        .toLowerCase()
+        .replace(/,/g, '')
+        .replace(/\s+/g, ' ')
+        .replace(/[\u200B-\u200D\uFEFF]/g, '')
+        .trim();
+
+    this.searchText = text;
+    const search = normalize(text);
+
+    if (!this.originalGroupEntries?.length) return;
+
+    // Build filtered branch groups
+    const filteredGroups = this.originalGroupEntries.map(group => {
+      const originalSendEntries = group.sendTransactions.entries || [];
+      const originalReceiveEntries = group.receiveTransactions.entries || [];
+
+      const filteredSend = search
+        ? originalSendEntries.filter(entry =>
+          Object.values(entry).some(value => normalize(value).includes(search))
+        )
+        : [...originalSendEntries];
+
+      const filteredReceive = search
+        ? originalReceiveEntries.filter(entry =>
+          Object.values(entry).some(value => normalize(value).includes(search))
+        )
+        : [...originalReceiveEntries];
+
+      return {
+        ...group,
+        sendTransactions: { ...group.sendTransactions, entries: filteredSend },
+        receiveTransactions: { ...group.receiveTransactions, entries: filteredReceive }
+      };
+    });
+
+    // 🔹 Keep only branches that have any matching entries
+    this.accountingReportModel.accountingReportByBranchGroups =
+      filteredGroups.filter(g =>
+        g.sendTransactions.entries.length > 0 || g.receiveTransactions.entries.length > 0
+      );
+
+    // Reset grids for visible branches
+    this.accountingReportModel.accountingReportByBranchGroups.forEach((group, index) => {
+      [group.sendTransactions.entries, group.receiveTransactions.entries].forEach((entries, idx) => {
+        const gridApi = this.gridApis[index * 2 + idx];
+        if (gridApi) {
+          gridApi.setRowData(entries);
+          if (gridApi.paginationGoToFirstPage) gridApi.paginationGoToFirstPage();
+        }
+      });
+    });
+
+  }
+
+  onGridReady(params: GridReadyEvent, id: number) {
+    this.gridApis[id] = params.api;
+    this.gridColumnApis[id] = params.columnApi;
+
+    setTimeout(() => this.autoSizeAllColumns(id), 100);
+  }
+
+
+  onGridSizeChanged(params: any, id: number) {
+    this.autoSizeAllColumns(id);
+  }
+
+
+  autoSizeAllColumns(id: number, skipHeader: boolean = false) {
+    const columnApi = this.gridColumnApis[id];
+    if (!columnApi) return;
+
+    const allColumnIds: string[] = [];
+    columnApi.getColumns().forEach((column: any) => {
+      allColumnIds.push(column.getId());
+    });
+
+    columnApi.autoSizeColumns(allColumnIds, skipHeader);
+  }
+
+
+  formatNumber(params: any): string {
+    if (params.value == null) return '';
+
+    const field = params.colDef.field;
+
+    if (field === 'settlementRate') {
+      return Number(params.value).toFixed(8);
+    }
+
+    return Number(params.value).toFixed(3);
+  }
+
+  private exportToPdf() {
+    if (!this.accountingReportModel.accountingReportByBranchGroups?.length) return;
+    const title = 'Accounting Report';
+    const fileName = 'Accounting-Report.pdf';
+
+    const metadata: [string, string][] = [
+      ['Report Period:', this.reportPeriod],
+      ['Report User & Time : ', `${this.reportUser}@${this.reportTime}`],
+    ];
+    // // --- search criteria ---
+    const searchCriteria = this.searchCriteria;
+
+    const doc = new jsPDF({ orientation: 'landscape', unit: 'mm', format: [700, 210] });
+
+    const logoWidth = 38.4, logoHeight = 17.5, logoX = 15, logoY = 8;
+    const pageWidth = doc.internal.pageSize.width;
+    const marginLeft = 15;
+    const titleY = 18;
+
+    // Logo
+    if (this.exportService['logoBase64']) {
+      doc.addImage(this.exportService['logoBase64'], 'PNG', logoX, logoY, logoWidth, logoHeight);
+    }
+
+    // Title
+    doc.setFontSize(15);
+    doc.setFont('helvetica', 'bold');
+    doc.text(title, pageWidth / 2, titleY, { align: 'center' });
+
+    let currentY = titleY + 14;
+
+    // Metadata
+    doc.setFontSize(10);
+    metadata.forEach(([label, value], i) => {
+      const y = currentY + i * 7;
+      doc.setFont('helvetica', 'bold');
+      doc.text(label, 15, y);
+      const labelWidth = doc.getTextWidth(label + ' ');
+      doc.setFont('helvetica', 'normal');
+      doc.text(value ?? '', 15 + labelWidth, y);
+    });
+    currentY += metadata.length * 7 + 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;
+    }
+    currentY += 8;
+    //==================================
+
+    // Branches
+    this.accountingReportModel.accountingReportByBranchGroups.forEach(group => {
+      doc.setFontSize(10);
+      doc.setFont('helvetica', 'bold');
+
+      const branchText = `Branch (Name & Code): ${group.branchNameAndCode}`;
+      doc.text(branchText, 15, currentY);
+      currentY += 7;
+
+      // Loop subgroups (Send + Receive)
+      [group.sendTransactions, group.receiveTransactions].forEach(subGroup => {
+        if (!subGroup.entries?.length) return;
+
+        doc.setFont('helvetica', 'bold');
+        doc.text(`Sub Group: ${subGroup.subGroupName}`, 15, currentY);
+        currentY += 5;
+
+        const { headers, rows } = this.prepareAccountingTable(subGroup.entries);
+
+        (doc as any).autoTable({
+          head: [headers],
+          body: rows,
+          startY: currentY,
+          theme: 'grid',
+          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 },
+        });
+
+        currentY = (doc as any).lastAutoTable.finalY + 10;
+      });
+    });
+
+    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 = doc.internal.pageSize.height - 6;
+
+      doc.text(
+        `Page ${i} of ${pageCount}`,
+        pageWidth - 15,
+        footerY,
+        { align: 'right' }
+      );
+    }
+
+    doc.save(fileName);
+  }
+
+  private exportToExcel() {
+    if (!this.accountingReportModel.accountingReportByBranchGroups?.length) return;
+    const title = 'Accounting Report';
+    const fileName = 'Accounting-Report.xlsx';
+
+    const workbook = new ExcelJS.Workbook();
+    const worksheet = workbook.addWorksheet('Accounting Report');
+    let currentRow = 1;
+
+    // Logo
+    if (this.exportService.logoBase64) {
+      const base64Data = this.exportService.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 }, editAs: 'oneCell' });
+    }
+
+    // Title
+    const titleRow = worksheet.getRow(currentRow);
+    titleRow.getCell(6).value = title;
+    titleRow.getCell(6).font = { bold: true, size: 16 };
+    titleRow.getCell(6).alignment = { vertical: 'middle', horizontal: 'left' };
+    worksheet.mergeCells(`F${currentRow}:J${currentRow}`);
+    currentRow += 3;
+
+    // Metadata
+    const metadata: [string, string][] = [
+      ['Report Period', this.reportPeriod],
+      ['Report User & Time : ', `${this.reportUser}@${this.reportTime}`],
+    ];
+    metadata.forEach(([label, value]) => {
+      const row = worksheet.getRow(currentRow++);
+      row.getCell(1).value = {
+        richText: [
+          { text: `${label}: `, font: { bold: true } },
+          { text: value ?? '', font: { bold: false } }
+        ]
+      };
+    });
+
+    worksheet.addRow([]); currentRow++;
+
+    // --- search criteria ---
+    const searchCriteria = this.searchCriteria;
+    // --- search criteria heading ---
+    // --- Heading ---
+    worksheet.mergeCells(currentRow, 1, currentRow, 8);
+    const headingCell = worksheet.getCell(currentRow, 1);
+    headingCell.value = 'Search Criteria:-';
+    headingCell.font = { bold: true, size: 12 };
+    headingCell.alignment = { vertical: 'middle', horizontal: 'left' };
+    currentRow += 2;
+
+    // --- Draw pairs dynamically (two per row) ---
+    const leftColEnd = 4; // columns 1–4 for left pair
+    const rightColStart = 5; // columns 5–8 for right pair
+
+    for (let i = 0; i < searchCriteria.length; i += 2) {
+      const row = worksheet.getRow(currentRow++);
+
+      // Left pair
+      if (searchCriteria[i]) {
+        const [key, value] = searchCriteria[i];
+        worksheet.mergeCells(row.number, 1, row.number, leftColEnd);
+        const leftCell = row.getCell(1);
+        leftCell.value = { richText: [{ text: key + ' ', font: { bold: true } }, { text: value }] };
+        leftCell.alignment = { vertical: 'middle', wrapText: true };
+      }
+
+      // Right pair
+      if (searchCriteria[i + 1]) {
+        const [key, value] = searchCriteria[i + 1];
+        worksheet.mergeCells(row.number, rightColStart, row.number, rightColStart + 3);
+        const rightCell = row.getCell(rightColStart);
+        rightCell.value = { richText: [{ text: key + ' ', font: { bold: true } }, { text: value }] };
+        rightCell.alignment = { vertical: 'middle', wrapText: true };
+      }
+    }
+    currentRow++;
+
+    // Branches
+    this.accountingReportModel.accountingReportByBranchGroups.forEach(group => {
+      const branchRow = worksheet.getRow(currentRow++);
+      branchRow.getCell(1).value = {
+        richText: [
+          { text: 'Branch (Name & Code): ', font: { bold: true } },
+          { text: group.branchNameAndCode ?? '', font: { bold: false } }
+        ]
+      };
+      worksheet.addRow([]); currentRow++;
+
+      // Loop subgroups
+      [group.sendTransactions, group.receiveTransactions].forEach(subGroup => {
+        if (!subGroup.entries?.length) return;
+
+        const subGroupRow = worksheet.getRow(currentRow++);
+        subGroupRow.getCell(1).value = {
+          richText: [
+            { text: 'Sub Group: ', font: { bold: true } },
+            { text: subGroup.subGroupName ?? '', font: { bold: false } }
+          ]
+        };
+
+        worksheet.addRow([]); currentRow++;
+
+        // Headers
+        const { headers, rows } = this.prepareAccountingTable(subGroup.entries);
+        const headerRow = worksheet.getRow(currentRow++);
+        headers.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' } };
+        });
+
+        // Rows
+        rows.forEach(r => {
+          const row = worksheet.getRow(currentRow++);
+          r.forEach((val, i) => {
+            const cell = row.getCell(i + 1);
+            cell.value = val;
+            cell.border = { top: { style: 'thin' }, bottom: { style: 'thin' }, left: { style: 'thin' }, right: { style: 'thin' } };
+          });
+        });
+
+        worksheet.addRow([]); currentRow++;
+      });
+    });
+
+    // Auto-adjust column widths (including Sr No)
+    const allHeaders = ['Sr No', ...this.columnDefs.map(c => c.headerName)];
+    allHeaders.forEach((header, i) => {
+      let maxLength = header.length; // start with header length
+
+      this.accountingReportModel.accountingReportByBranchGroups.forEach(group => {
+        [group.sendTransactions, group.receiveTransactions].forEach(subGroup => {
+          subGroup.entries.forEach(entry => {
+            // Sr No column (i = 0) is just numbers
+            let val = i === 0 ? (subGroup.entries.indexOf(entry) + 1).toString() : (entry[this.columnDefs[i - 1]?.field] ?? '');
+            const len = val.toString().length;
+            if (len > maxLength) maxLength = len;
+          });
+        });
+      });
+
+      worksheet.getColumn(i + 1).width = maxLength + 5; // padding
+    });
+
+    workbook.xlsx.writeBuffer().then(buffer => {
+      const blob = new Blob([buffer], {
+        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+      });
+      FileSaver.saveAs(blob, fileName);
+    });
+  }
+
+
+
+
+
+  private prepareAccountingTable(data: any[]): { headers: string[], rows: any[][] } {
+    const currencyFields = ['amountPaid', 'serviceFee', 'tax', 'principleSendAmount', 'clientSettlementInSCcy'];
+    const headers = ['Sr No', ...this.columnDefs.map(c => c.headerName)];
+
+    if (!data || data.length === 0) {
+      return { headers, rows: [] }; // return headers only, empty rows
+    }
+
+    const rows = data.map((row, i) => {
+      return [
+        i + 1,
+        ...this.columnDefs.map(col => {
+          let val = row[col.field];
+          if (val == null) return '';
+          if (currencyFields.includes(col.field)) return parseFloat(val).toFixed(3);
+          if (col.field === 'settlementRate') return parseFloat(val).toFixed(8);
+          return val;
+        })
+      ];
+    });
+
+    return { headers, rows };
+  }
+
+  private exportToCsv() {
+    if (!this.accountingReportModel.accountingReportByBranchGroups?.length) return;
+    const fileName = 'Accounting-Report.csv';
+    const rows: string[] = [];
+
+    rows.push('Report Title: Accounting Report');
+    rows.push('');
+    rows.push(`Report Period: ${this.reportPeriod}`);
+    rows.push(`Report User & Time: ${this.reportUser}@${this.reportTime}`);
+    rows.push('');
+
+    // // --- search criteria ---
+    const searchCriteria = this.searchCriteria;
+
+    if (searchCriteria?.length) {
+      rows.push('Search Criteria:-');
+
+      // calculate max length of left key-value pairs for padding
+      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]}` : '';
+
+        //  Each row in single CSV row; first and second pair separated by a column
+        rows.push(`"${leftText}${rightText}"`);
+      }
+      rows.push(''); // blank line after search criteria
+    }
+
+    this.accountingReportModel.accountingReportByBranchGroups.forEach(group => {
+      rows.push(`Branch (Name & Code): ${group.branchNameAndCode}`);
+
+      [group.sendTransactions, group.receiveTransactions].forEach(subGroup => {
+        if (!subGroup.entries?.length) return;
+
+        rows.push(`Sub Group: ${subGroup.subGroupName}`);
+
+        //  Add "Sr No" at the beginning of headers
+        rows.push(['"Sr No"', ...this.columnDefs.map(col => `"${col.headerName}"`)].join(','));
+
+        subGroup.entries.forEach((entry, idx) => {
+          //  Add serial number at start of each row
+          const row = [
+            (idx + 1).toString(),
+            ...this.columnDefs.map(col => {
+              const val = entry[col.field];
+              if (val == null) return '';
+              if (['amountPaid', 'serviceFee', 'tax', 'principleSendAmount', 'clientSettlementInSCcy'].includes(col.field)) {
+                return parseFloat(val).toFixed(3);
+              }
+              if (col.field === 'settlementRate') {
+                return parseFloat(val).toFixed(8);
+              }
+              return `"${val}"`;
+            })
+          ].join(',');
+          rows.push(row);
+        });
+
+        rows.push('');
+      });
+    });
+
+    const blob = new Blob([rows.join('\n')], { type: 'text/csv;charset=utf-8;' });
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(blob);
+    link.setAttribute('download', fileName);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+  }
+
+
+
+
+
+  getReport(payload: any) {
+    const modal = payload?.modal || payload;
+
+    const req: AccountingReportRequest = {
+      startDate: modal.fromDate, // yyyy-MM-dd from the filter
+      endDate: modal.toDate,
+      sendCountryCode: modal.sendCountry ?? 'ALL',
+      recvCountryCode: modal.receiveCountry ?? 'ALL',
+      businessPartnerCorrelationID: modal.client ?? 'ALL',
+      transactionStatus: modal.transactionStatus.join(","),
+      payoutCurrency: modal.currency ?? 'ALL',
+      transactionType: modal.product ?? 'ALL',
+      branchCode: modal.branch ?? 'ALL',
+      companyCode: 'ALL' // or 'BH' if your API requires it specifically
+    };
+
+    this.searchCriteria = payload.searchCriteria;
+
+    this.getAccountingReport(req);
+  }
+
+  handleFormValid(isValid: boolean): void {
+    this.isFormValid = isValid;
+  }
+
+}