tango-app-ui-manage-billing 3.3.41 → 3.3.43

package/esm2022/lib/components/daily-pricing/daily-pricing.component.mjs

@@ -456,14 +456,28 @@ export class DailyPricingComponent {
             outstandingGroupIds,
         };
         this.billingService.createInvoice(payload).pipe(takeUntil(this.destroy$)).subscribe({
-            next: () => {
+            next: (res) => {
                 this.generatingInvoice = false;
-                this.toast.getPrimaryToast(`Invoice generated for ${groupIds.length} billing group(s)`);
+                // A partial batch (some groups written, some refused because an advance
+                // invoice already covers this month) comes back as a success whose
+                // message names the skipped groups — show that instead of the generic
+                // "generated for N groups", which would overstate what was created.
+                const msg = typeof res?.message === 'string' ? res.message : '';
+                if (msg.includes('Skipped:')) {
+                    this.toast.getErrorToast(msg);
+                }
+                else {
+                    this.toast.getPrimaryToast(`Invoice generated for ${groupIds.length} billing group(s)`);
+                }
                 this.changeDetector.detectChanges();
             },
-            error: () => {
+            error: (err) => {
                 this.generatingInvoice = false;
-                this.toast.getErrorToast('Failed to generate invoice');
+                // Surface the backend's exact reason (e.g. "Advance invoice TINV-… already
+                // covers Aug 2026 … Cancel it before generating a new advance invoice.")
+                // instead of a generic failure.
+                // sendError() puts the text under `error`; `message` is kept as a fallback.
+                this.toast.getErrorToast(err?.error?.error || err?.error?.message || 'Failed to generate invoice');
                 this.changeDetector.detectChanges();
             }
         });
@@ -524,4 +538,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         }], ctorParameters: () => [{ type: i1.BillingService }, { type: i0.ChangeDetectorRef }, { type: i2.ToastService }, { type: i3.NgbModal }], propDecorators: { clientId: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daily-pricing.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-billing/src/lib/components/daily-pricing/daily-pricing.component.ts","../../../../../../projects/tango-manage-billing/src/lib/components/daily-pricing/daily-pricing.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, Input, OnInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport { NgbModal } from '@ng-bootstrap/ng-bootstrap';\nimport { BillingService } from '../services/billing.service';\nimport { ToastService } from 'tango-app-ui-shared';\nimport { GenerateInvoiceModalComponent } from './generate-invoice-modal/generate-invoice-modal.component';\nimport { NewStoresModalComponent } from './new-stores-modal/new-stores-modal.component';\n\n@Component({\n  selector: 'lib-daily-pricing',\n  templateUrl: './daily-pricing.component.html',\n  styleUrl: './daily-pricing.component.scss'\n})\nexport class DailyPricingComponent implements OnInit, OnChanges, OnDestroy {\n  private readonly destroy$ = new Subject();\n\n  @Input() clientId: string = '';\n\n  len: any;\n  searchDisabled: boolean = false;\n\n  // Metadata\n  dailyPricingInfo: any = {};\n\n  // Edit tracking: key = 'storeId_productName', value = edited workingdays\n  editingProduct: any = {};\n  // Edit tracking for store-level fields (trafficCameraCount, zoneCameraCount, zoneCount)\n  editingField: any = {};\n\n  // Date filter\n  dateFilter: string = '';\n\n  // Filter — multi-select status. No default: the table opens showing ALL\n  // stores (active + deactive); neither option is pre-checked.\n  statusFilter: string[] = [];\n  // Multi-select country filter (options populated from the API's `countries`).\n  countryFilter: string[] = [];\n  storeFilterObject: any[] = [\n    { Description: 'Status', type: 'multi', Issues: [{ id: 'active', text: 'Active' }, { id: 'deactive', text: 'Deactive' }] },\n  ];\n  // lib-filters snapshots dataObject in its ngOnInit, so the Country group must\n  // be present BEFORE it mounts. We gate the <lib-filters> render on this flag,\n  // flipping it true only once the country options have been built from the API.\n  filtersReady: boolean = false;\n\n  // Monthly Billing Summary — derived from invoice history for the brand.\n  // Newest first; each row carries prior-month deltas for the trend indicator.\n  monthlyBillingSummary: any[] = [];\n  monthlySummaryExpanded: boolean = false;\n\n  // Table\n  storeList: any = [];\n  storeLoading: boolean = true;\n  storeNoData: boolean = false;\n  totalItems: number = 0;\n  pageSize: number = 10;\n  currentPage: number = 1;\n  itemsPerPage: number = 10;\n  paginationSizes = [10, 20, 30];\n  // Default sort: working days (daysDifference), highest first.\n  sortColumName: string = 'daysDifference';\n  sortBy: number = -1;\n  generatingInvoice: boolean = false;\n\n  // Additional (non-standard) products available only for specific clients\n  // (currently clientId 11). Empty for everyone else -> the table is hidden.\n  additionalProducts: any[] = [];\n  additionalProductsCurrency: string = 'inr';\n  // Date (YYYY-MM-DD) of the billing_details snapshot behind the additional\n  // product counts; passed to the export so exports match the displayed cards.\n  additionalProductsDate: string = '';\n\n  // Count + list of stores onboarded this month (first file date in the current\n  // month). The list feeds the \"View Stores\" popup.\n  newlyOnboardedStores: number = 0;\n  newlyOnboardedStoreList: any[] = [];\n\n  constructor(\n    private billingService: BillingService,\n    private changeDetector: ChangeDetectorRef,\n    private toast: ToastService,\n    private modalService: NgbModal\n  ) {}\n\n  ngOnInit(): void {\n    if (this.clientId) {\n      this.loadDailyPricing();\n      this.loadAdditionalProducts();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['clientId'] && !changes['clientId'].firstChange && this.clientId) {\n      this.loadDailyPricing();\n      this.loadAdditionalProducts();\n    }\n  }\n\n  // Grand total across all additional-product rows.\n  get additionalProductsTotal(): number {\n    return (this.additionalProducts || []).reduce((a, p) => a + (Number(p.total) || 0), 0);\n  }\n\n  // Products that have a backend detailed export. Keyed by the product key the\n  // export endpoint understands. Add more as their queries are wired up.\n  private readonly exportableProducts: Record<string, string> = {\n    'eyetest': 'eyetest',\n    'eyetest (additional storage)': 'eyetestadditionalstorage',\n    'planogram': 'planogram',\n    'ai manager': 'aimanager',\n    'vms': 'vms',\n    // 'Run AI' is displayed as 'AI in checklist'; both map to the same export\n    // key so the download works whichever label the API returns.\n    'run ai': 'runai',\n    'ai in checklist': 'runai',\n    'remote optum': 'remoteoptum',\n    // Factory QC (FactoryQC_billing Lambda). Day-scoped: the Lambda takes only\n    // report_date, so this export covers the snapshot date shown on the card\n    // rather than month-to-date like Remote Optum.\n    'factory': 'factory',\n  };\n\n  canExportAdditionalProduct(productName: string): boolean {\n    return !!this.exportableProducts[(productName || '').toLowerCase()];\n  }\n\n  exportAdditionalProduct(productName: string): void {\n    const key = this.exportableProducts[(productName || '').toLowerCase()];\n    if (!key) {\n      return;\n    }\n    // Pass the billing_details snapshot date (YYYY-MM-DD) behind the card counts\n    // so day-scoped exports (VMS / Run AI via Lambda to_date, Remote Optum) match\n    // what's shown. Fall back to today if the backend didn't return a date.\n    const today = new Date();\n    const todayStr = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;\n    const exportDate = this.additionalProductsDate || todayStr;\n    this.billingService.additionalProductExport(this.clientId, key, exportDate)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe({\n        next: (res: ArrayBuffer) => {\n          // A real .xlsx is a zip — its first two bytes are 'PK' (0x50 0x4B).\n          // A 204/empty or JSON error body is NOT, and saving it produces a\n          // \"corrupted\" file. Guard so we only save a genuine workbook.\n          const bytes = res ? new Uint8Array(res) : new Uint8Array();\n          const isXlsx = bytes.length > 1 && bytes[0] === 0x50 && bytes[1] === 0x4b;\n          if (!isXlsx) {\n            this.toast.getErrorToast('No data to export');\n            return;\n          }\n          this.billingService.saveAsExcelFile(res, `${productName}-${this.clientId}`);\n        },\n        error: () => {\n          this.toast.getErrorToast('Export failed');\n        },\n      });\n  }\n\n  // Fetch the additional-products table for this client. Backend returns an\n  // empty list for any client that has none (so the table just won't render).\n  loadAdditionalProducts() {\n    // Send the page's selected date (if any) so the section reflects it.\n    this.billingService.additionalProducts(this.clientId, this.dateFilter || undefined).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (res) => {\n        this.additionalProducts = res?.data?.products || [];\n        this.additionalProductsCurrency = res?.data?.currency || 'inr';\n        this.additionalProductsDate = res?.data?.billingDate || '';\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        this.additionalProducts = [];\n        this.changeDetector.detectChanges();\n      },\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next(true);\n    this.destroy$.complete();\n  }\n\n  loadDailyPricing() {\n    this.searchDisabled = false;\n    this.storeLoading = true;\n    this.storeNoData = false;\n\n    let filters: Record<string, any> = {\n      clientId: this.clientId,\n      limit: this.pageSize,\n      offset: this.currentPage,\n      searchValue: this.len,\n      sortColumName: this.sortColumName,\n      sortBy: this.sortBy,\n      statusFilter: this.statusFilter,\n      countryFilter: this.countryFilter,\n      dateFilter: this.dateFilter || '',\n      export: false\n    };\n\n    this.billingService.latestDailyPricing(filters).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (e) => {\n        // The Monthly Billing Summary comes from invoice history, not the store\n        // rows — apply it regardless of whether the store list is empty, so it\n        // still shows when the filtered store table has no rows.\n        this.monthlyBillingSummary = this.decorateMonthlySummary(e?.data?.monthlyBillingSummary || []);\n        // Newly onboarded count/list is independent of the store table's\n        // filters, so capture it whether or not the filtered store list has rows.\n        this.newlyOnboardedStores = e?.data?.newlyOnboardedStores || 0;\n        this.newlyOnboardedStoreList = e?.data?.newlyOnboardedStoreList || [];\n\n        // Populate the Country filter options from the API's country list (all\n        // client stores). Independent of the filtered store count, so build it\n        // even when the filtered table is empty.\n        this.buildCountryFilterOptions(e?.data?.countries || []);\n\n        if (e?.data?.count) {\n          this.storeLoading = false;\n          this.storeNoData = false;\n          this.storeList = e.data?.data;\n          this.totalItems = e.data?.count;\n\n          this.dailyPricingInfo = {\n            brandName: e.data?.brandName || '',\n            dateString: e.data?.dateString || '',\n            dateISO: e.data?.dateISO || '',\n            activeStores: e.data?.activeStores || 0,\n            accountType: e.data?.accountType || '',\n            status: e.data?.status || '',\n            proRate: e.data?.proRate || '',\n            clientId: e.data?.clientId || ''\n          };\n\n          this.changeDetector.detectChanges();\n        } else {\n          this.storeLoading = false;\n          this.storeNoData = true;\n          this.searchDisabled = true;\n          if (this.len?.length) {\n            this.searchDisabled = false;\n          }\n          this.storeList = [];\n          this.totalItems = 0;\n          this.changeDetector.detectChanges();\n        }\n      },\n      error: () => {\n        this.storeLoading = false;\n        this.storeNoData = true;\n        this.storeList = [];\n        this.totalItems = 0;\n        this.monthlyBillingSummary = [];\n        this.changeDetector.detectChanges();\n      }\n    });\n  }\n\n  onDateFilter(event: any) {\n    this.dateFilter = event?.target?.value || '';\n    this.currentPage = 1;\n    this.loadDailyPricing();\n    // Additional Products reflect the selected date too.\n    this.loadAdditionalProducts();\n  }\n\n  clearDateFilter() {\n    this.dateFilter = '';\n    this.currentPage = 1;\n    this.loadDailyPricing();\n    this.loadAdditionalProducts();\n  }\n\n  searchField() {\n    this.currentPage = 1;\n    this.loadDailyPricing();\n  }\n\n  // Add/refresh the Country group in the filter dropdown from the API's country\n  // list, preserving the current selection (checked). lib-filters snapshots\n  // dataObject only in ngOnInit, so we build the full storeFilterObject here and\n  // then flip filtersReady to mount <lib-filters> once — after which it sees both\n  // Status and Country groups.\n  private buildCountryFilterOptions(countries: string[]) {\n    const list = Array.isArray(countries) ? countries.filter(Boolean) : [];\n    if (list.length) {\n      const selected = new Set(this.countryFilter);\n      const issues = list.map((c) => ({ id: c, text: c, checked: selected.has(c) }));\n      const existing = this.storeFilterObject.find((g) => g.Description === 'Country');\n      if (existing) {\n        existing.Issues = issues;\n      } else {\n        this.storeFilterObject = [...this.storeFilterObject, { Description: 'Country', type: 'multi', Issues: issues }];\n      }\n    }\n    // Mount lib-filters once the first response is in (Status alone if there are\n    // no countries), so it snapshots the full dataObject on init.\n    if (!this.filtersReady) {\n      this.filtersReady = true;\n    }\n  }\n\n  applyStoreFilters(event: any) {\n    // Multi-select Status / Country — lib-filters emits each group's selected\n    // options as an ARRAY under Issues (Apply sets Issues = selectedValuesArray\n    // [index]). Collect every selected id, tolerating array and single-object\n    // shapes.\n    const statuses: string[] = [];\n    const countries: string[] = [];\n    if (event?.length) {\n      event.forEach((element: any) => {\n        const issues = Array.isArray(element.Issues) ? element.Issues : (element.Issues ? [element.Issues] : []);\n        if (element.Description === 'Status') {\n          issues.forEach((i: any) => { if (i?.id) statuses.push(i.id); });\n        } else if (element.Description === 'Country') {\n          issues.forEach((i: any) => { if (i?.id) countries.push(i.id); });\n        }\n      });\n    }\n    this.statusFilter = [...new Set(statuses)];\n    this.countryFilter = [...new Set(countries)];\n    this.currentPage = 1;\n    this.loadDailyPricing();\n  }\n\n  sortData(column: string) {\n    this.sortColumName = column;\n    this.sortBy *= -1;\n    this.changeDetector.detectChanges();\n    this.loadDailyPricing();\n  }\n\n  onPageChange(pageOffset: any) {\n    this.currentPage = parseInt(pageOffset);\n    this.loadDailyPricing();\n  }\n\n  onPageSizeChange(pageSize: any) {\n    this.currentPage = 1;\n    this.pageSize = parseInt(pageSize);\n    this.loadDailyPricing();\n  }\n\n  onExport() {\n    let filters: Record<string, any> = {\n      clientId: this.clientId,\n      searchValue: this.len,\n      sortColumName: this.sortColumName,\n      sortBy: this.sortBy,\n      statusFilter: this.statusFilter,\n      dateFilter: this.dateFilter || '',\n      export: true\n    };\n\n    this.billingService.latestDailyPricingExport(filters).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (res) => {\n        // saveAsTemplate (not saveAsExcelFile) — the latter appends a \"list\"\n        // suffix, which would download this as \"Annexurelist.xlsx\".\n        this.billingService.saveAsTemplate(res, 'Annexure');\n      },\n      error: () => {\n        this.toast.getErrorToast('Something went Wrong..');\n      }\n    });\n  }\n\n  getEditKey(storeId: string, productName: string): string {\n    return `${storeId}_${productName}`;\n  }\n\n  isEditing(storeId: string, productName: string): boolean {\n    return this.editingProduct[this.getEditKey(storeId, productName)] !== undefined;\n  }\n\n  startEdit(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    // Coerce to a number so a 0 / missing value still enters edit mode with a\n    // defined value (undefined would make isEditing() think we're not editing).\n    this.editingProduct[key] = Number(product.workingdays) || 0;\n  }\n\n  cancelEdit(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    delete this.editingProduct[key];\n  }\n\n  saveWorkingDays(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    const newValue = Number(this.editingProduct[key]) || 0;\n\n    // Unchanged → just close the editor (compare as numbers so 0 vs \"0\" etc.\n    // don't slip through).\n    if (newValue === (Number(product.workingdays) || 0)) {\n      delete this.editingProduct[key];\n      return;\n    }\n\n    const payload = {\n      clientId: this.clientId,\n      dateString: this.dailyPricingInfo.dateString,\n      storeId: store.storeId,\n      productName: product.productName,\n      workingdays: newValue\n    };\n\n    this.billingService.updateDailyPricingWorkingDays(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: () => {\n        product.workingdays = Number(newValue);\n        delete this.editingProduct[key];\n        this.toast.getPrimaryToast('Working days updated successfully');\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        this.toast.getErrorToast('Failed to update working days');\n      }\n    });\n  }\n\n  getFieldEditKey(storeId: string, fieldName: string): string {\n    return `${storeId}_${fieldName}`;\n  }\n\n  isEditingField(storeId: string, fieldName: string): boolean {\n    return this.editingField[this.getFieldEditKey(storeId, fieldName)] !== undefined;\n  }\n\n  startFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    this.editingField[key] = store[fieldName] || 0;\n  }\n\n  cancelFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    delete this.editingField[key];\n  }\n\n  saveFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    const newValue = this.editingField[key];\n\n    if (newValue === store[fieldName]) {\n      delete this.editingField[key];\n      return;\n    }\n\n    const payload = {\n      clientId: this.clientId,\n      dateString: this.dailyPricingInfo.dateString,\n      storeId: store.storeId,\n      fieldName: fieldName,\n      value: Number(newValue)\n    };\n\n    this.billingService.updateDailyPricingStoreField(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: () => {\n        store[fieldName] = Number(newValue);\n        delete this.editingField[key];\n        const fieldLabels: Record<string, string> = { trafficCameraCount: 'Traffic camera count', zoneCameraCount: 'Zone camera count', zoneCount: 'Zone count' };\n        this.toast.getPrimaryToast(`${fieldLabels[fieldName] || fieldName} updated successfully`);\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        const errorLabels: Record<string, string> = { trafficCameraCount: 'traffic camera count', zoneCameraCount: 'zone camera count', zoneCount: 'zone count' };\n        this.toast.getErrorToast(`Failed to update ${errorLabels[fieldName] || fieldName}`);\n      }\n    });\n  }\n\n  generateInvoice() {\n    if (!this.clientId) return;\n    // Open the picker first — the user chooses which billing groups to\n    // generate for. Modal closes with { groupIds, outstandingGroupIds }\n    // (or is dismissed = no-op).\n    const modalRef = this.modalService.open(GenerateInvoiceModalComponent, {\n      centered: true, size: 'md', scrollable: true,\n    });\n    modalRef.componentInstance.clientId = this.clientId;\n    modalRef.result.then((result: { groupIds: string[]; outstandingGroupIds: string[] }) => {\n      if (!result || !Array.isArray(result.groupIds) || result.groupIds.length === 0) return;\n      this.runInvoiceGeneration(result.groupIds, result.outstandingGroupIds || []);\n    }).catch(() => {});\n  }\n\n  // Open a popup listing the newly onboarded stores (with first file date).\n  // The list is already loaded with the page, so no extra API call is needed.\n  viewNewStores(): void {\n    if (!this.newlyOnboardedStoreList.length) return;\n    const modalRef = this.modalService.open(NewStoresModalComponent, {\n      centered: true, size: 'lg', scrollable: true,\n    });\n    modalRef.componentInstance.stores = this.newlyOnboardedStoreList;\n    // Needed by the modal's Export button so the sheet is built from the same\n    // client and daily-pricing snapshot the popup is showing.\n    modalRef.componentInstance.clientId = this.clientId;\n    modalRef.componentInstance.dateFilter = this.dateFilter || '';\n  }\n\n  private runInvoiceGeneration(groupIds: string[], outstandingGroupIds: string[] = []): void {\n    this.generatingInvoice = true;\n\n    const payload = {\n      allClient: true,\n      clientList: [this.clientId],\n      groupIds,\n      outstandingGroupIds,\n    };\n\n    this.billingService.createInvoice(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: () => {\n        this.generatingInvoice = false;\n        this.toast.getPrimaryToast(`Invoice generated for ${groupIds.length} billing group(s)`);\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        this.generatingInvoice = false;\n        this.toast.getErrorToast('Failed to generate invoice');\n        this.changeDetector.detectChanges();\n      }\n    });\n  }\n\n  formatProductName(name: string): string {\n    if (!name) return '';\n    return name.replace(/([a-z])([A-Z])/g, '$1 $2')\n      .replace(/^./, (str) => str.toUpperCase());\n  }\n\n  // Take the raw aggregation rows (already sorted newest-first by the API) and\n  // attach (a) a human-readable monthLabel, (b) tag for the latest two rows\n  // (\"Current\" / \"Last generated\") and (c) deltas vs the immediately older\n  // Currency symbol for a store's invoice amount (matches the backend's\n  // basepricing currency; AED rendered as text).\n  storeCurrencySymbol(store: any): string {\n    const symbols: Record<string, string> = { inr: '₹', dollar: '$', singaporedollar: 'S$', euro: '€', aed: 'AED ' };\n    return symbols[(store?.invoiceCurrency || 'inr').toLowerCase()] || '₹';\n  }\n\n  // month so the template can render the ▲/▼/▬ trend indicators.\n  private decorateMonthlySummary(rows: any[]): any[] {\n    if (!Array.isArray(rows) || rows.length === 0) return [];\n    const monthNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];\n    const symbols: Record<string, string> = { inr: '₹', dollar: '$', singaporedollar: 'S$', euro: '€' };\n    const now = new Date();\n    const isCurrent = (r: any) => r.year === now.getFullYear() && r.month === (now.getMonth() + 1);\n    return rows.map((r, i) => {\n      const next = rows[i + 1];\n      const storesDelta = next ? (r.storesBilled || 0) - (next.storesBilled || 0) : null;\n      const amountDelta = next ? (r.invoiceAmount || 0) - (next.invoiceAmount || 0) : null;\n      let tag = '';\n      if (isCurrent(r)) tag = 'Current';\n      else if (i === 0) tag = 'Last generated';\n      else if (i === 1 && isCurrent(rows[0])) tag = 'Last generated';\n      return {\n        ...r,\n        monthLabel: `${monthNames[(r.month || 1) - 1]} ${r.year}`,\n        tag,\n        storesDelta,\n        amountDelta,\n        currencySymbol: symbols[(r.currency || 'inr').toLowerCase()] || '',\n      };\n    });\n  }\n\n  toggleMonthlySummaryHistory(): void {\n    this.monthlySummaryExpanded = !this.monthlySummaryExpanded;\n  }\n}","<div class=\"invoices-section\">\n    <!-- Header Row -->\n    <div class=\"d-flex justify-content-between align-items-center mb-3\">\n        <div>\n            <div class=\"d-flex align-items-center gap-2\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\n                    <path d=\"M6.66667 10H13.3333M6.66667 6.66667H13.3333M6.66667 13.3333H10M5 17.5H15C15.9205 17.5 16.6667 16.7538 16.6667 15.8333V4.16667C16.6667 3.24619 15.9205 2.5 15 2.5H5C4.07953 2.5 3.33333 3.24619 3.33333 4.16667V15.8333C3.33333 16.7538 4.07953 17.5 5 17.5Z\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                </svg>\n                <span class=\"billingheader\">Billing Breakdown</span>\n                <span class=\"badge bg-light text-dark ms-1\">{{ totalItems }} stores</span>\n            </div>\n            <div class=\"text-muted small mt-1\" *ngIf=\"dailyPricingInfo?.dateString\">\n                Date: <strong>{{ dailyPricingInfo?.dateString }}</strong>\n                <span class=\"mx-2\">|</span>\n                Active Stores: <strong>{{ dailyPricingInfo?.activeStores }}</strong>\n                <span class=\"mx-2\">|</span>\n                Account Type: <strong>{{ dailyPricingInfo?.accountType }}</strong>\n            </div>\n        </div>\n        <div class=\"d-flex align-items-center gap-3\">\n            <div class=\"d-flex align-items-center gap-2\">\n                <input type=\"date\" class=\"form-control form-control-sm date-filter\"\n                    [value]=\"dateFilter\"\n                    (change)=\"onDateFilter($event)\"\n                    placeholder=\"Filter by date\">\n                <button *ngIf=\"dateFilter\" type=\"button\" class=\"btn btn-sm btn-outline-secondary\"\n                    (click)=\"clearDateFilter()\" title=\"Clear date filter\">\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                        <path d=\"M10.5 3.5L3.5 10.5M3.5 3.5L10.5 10.5\" stroke=\"#667085\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                    </svg>\n                </button>\n            </div>\n            <button type=\"button\" (click)=\"generateInvoice()\"\n                class=\"btn btn-primary align-items-end text-nowrap invheader\"\n                [disabled]=\"!storeList.length || generatingInvoice\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 20 20\" fill=\"none\">\n                    <path d=\"M6.66667 10H13.3333M6.66667 6.66667H13.3333M6.66667 13.3333H10M5 17.5H15C15.9205 17.5 16.6667 16.7538 16.6667 15.8333V4.16667C16.6667 3.24619 15.9205 2.5 15 2.5H5C4.07953 2.5 3.33333 3.24619 3.33333 4.16667V15.8333C3.33333 16.7538 4.07953 17.5 5 17.5Z\"\n                        stroke=\"#fff\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                </svg>\n                <span class=\"ms-1\">{{ generatingInvoice ? 'Generating...' : 'Generate Invoice' }}</span>\n            </button>\n        </div>\n    </div>\n\n    <!-- Newly Onboarded Stores — stores whose first file date is in the current month -->\n    <div class=\"d-flex mb-4\">\n        <div class=\"newly-onboarded-card\"\n            style=\"display:flex;align-items:center;gap:14px;border:1px solid #E4E7EC;border-radius:10px;padding:14px 18px;background:#fff;min-width:240px;\">\n            <div style=\"width:40px;height:40px;border-radius:8px;background:#EAF8FF;display:flex;align-items:center;justify-content:center;\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"22\" height=\"22\" viewBox=\"0 0 24 24\" fill=\"none\">\n                    <path d=\"M3 21V8l9-5 9 5v13M3 21h18M3 21H1m20 0h2M9 21v-6h6v6M12 7.5h.01\" stroke=\"#00A3FF\" stroke-width=\"1.6\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                </svg>\n            </div>\n            <div>\n                <div style=\"font-size:24px;font-weight:700;color:#101828;line-height:1.1;\">{{ newlyOnboardedStores | number:'1.0-0':'en-IN' }}</div>\n                <div style=\"font-size:13px;color:#667085;\">Newly Onboarded Stores</div>\n                <div style=\"font-size:11px;color:#98A2B3;\">First file in current month</div>\n            </div>\n            <button type=\"button\" class=\"btn btn-sm btn-outline-primary ms-3\"\n                [disabled]=\"!newlyOnboardedStores\"\n                (click)=\"viewNewStores()\">View Stores</button>\n        </div>\n    </div>\n\n    <!-- Monthly Billing Summary — invoice trend (newest first, with deltas vs prior month) -->\n    <div class=\"monthly-billing-summary\" *ngIf=\"monthlyBillingSummary?.length\">\n        <div class=\"msum-header\">Monthly Billing Summary</div>\n        <div class=\"table-responsive\">\n            <table class=\"table mb-0\">\n                <thead>\n                    <tr>\n                        <th>MONTH</th>\n                        <th>NUMBER OF STORES BILLED</th>\n                        <th>INVOICE AMOUNT</th>\n                    </tr>\n                </thead>\n                <tbody>\n                    <ng-container *ngFor=\"let row of monthlyBillingSummary; let i = index\">\n                        <tr *ngIf=\"i < 2 || monthlySummaryExpanded\" [class.curr]=\"row.tag === 'Current'\">\n                            <td>\n                                <strong>{{ row.monthLabel }}</strong>\n                                <span *ngIf=\"row.tag === 'Current'\" class=\"badge badge-light-primary ms-2\">Current</span>\n                                <span *ngIf=\"row.tag === 'Last generated'\" class=\"badge bg-light text-dark ms-2\">Last generated</span>\n                            </td>\n                            <td>\n                                <strong>{{ row.storesBilled }}</strong>\n                                <span *ngIf=\"row.storesDelta !== null\" class=\"ind ms-2\"\n                                    [class.up]=\"row.storesDelta > 0\"\n                                    [class.down]=\"row.storesDelta < 0\"\n                                    [class.flat]=\"row.storesDelta === 0\">\n                                    <ng-container [ngSwitch]=\"true\">\n                                        <ng-container *ngSwitchCase=\"row.storesDelta > 0\">▲ {{ row.storesDelta }}</ng-container>\n                                        <ng-container *ngSwitchCase=\"row.storesDelta < 0\">▼ {{ -row.storesDelta }}</ng-container>\n                                        <ng-container *ngSwitchDefault>▬ 0</ng-container>\n                                    </ng-container>\n                                </span>\n                            </td>\n                            <td>\n                                <strong>{{ row.currencySymbol }}{{ row.invoiceAmount | number:'1.2-2':'en-IN' }}</strong>\n                                <span *ngIf=\"row.amountDelta !== null\" class=\"ind ms-2\"\n                                    [class.up]=\"row.amountDelta > 0\"\n                                    [class.down]=\"row.amountDelta < 0\"\n                                    [class.flat]=\"row.amountDelta === 0\">\n                                    <ng-container [ngSwitch]=\"true\">\n                                        <ng-container *ngSwitchCase=\"row.amountDelta > 0\">▲ {{ row.currencySymbol }}{{ row.amountDelta | number:'1.2-2':'en-IN' }}</ng-container>\n                                        <ng-container *ngSwitchCase=\"row.amountDelta < 0\">▼ {{ row.currencySymbol }}{{ -row.amountDelta | number:'1.2-2':'en-IN' }}</ng-container>\n                                        <ng-container *ngSwitchDefault>▬ 0</ng-container>\n                                    </ng-container>\n                                </span>\n                            </td>\n                        </tr>\n                    </ng-container>\n                </tbody>\n            </table>\n        </div>\n        <div *ngIf=\"monthlyBillingSummary.length > 2\" class=\"msum-toggle\" (click)=\"toggleMonthlySummaryHistory()\">\n            <ng-container *ngIf=\"!monthlySummaryExpanded\">▾ Show older months ({{ monthlyBillingSummary.length - 2 }})</ng-container>\n            <ng-container *ngIf=\"monthlySummaryExpanded\">▴ Hide older months</ng-container>\n        </div>\n    </div>\n\n    <!-- Additional Products — non-standard products billed for this client only\n         (e.g. clientId 11: Eyetest, Planogram). Hidden when the client has none. -->\n    <div class=\"monthly-billing-summary\" *ngIf=\"additionalProducts?.length\">\n        <div class=\"msum-header\">Additional Products</div>\n        <div class=\"table-responsive\">\n            <table class=\"table mb-0\">\n                <thead>\n                    <tr>\n                        <th>Product Name</th>\n                        <th class=\"text-end\">Quantity</th>\n                        <th class=\"text-end\">Price</th>\n                        <th class=\"text-end\">Total</th>\n                        <th class=\"text-center\">Action</th>\n                    </tr>\n                </thead>\n                <tbody>\n                    <tr *ngFor=\"let p of additionalProducts\">\n                        <td>{{ p.productName }}</td>\n                        <td class=\"text-end\">{{ p.quantity | number:'1.0-0':'en-IN' }}</td>\n                        <td class=\"text-end\">{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ p.price | number:'1.2-2':'en-IN' }}</td>\n                        <td class=\"text-end\"><strong>{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ p.total | number:'1.2-2':'en-IN' }}</strong></td>\n                        <td class=\"text-center\">\n                            <button type=\"button\" class=\"btn btn-sm btn-outline-primary\"\n                                *ngIf=\"canExportAdditionalProduct(p.productName)\"\n                                (click)=\"exportAdditionalProduct(p.productName)\">\n                                Download\n                            </button>\n                        </td>\n                    </tr>\n                    <tr>\n                        <td colspan=\"3\" class=\"text-end\"><strong>Grand Total</strong></td>\n                        <td class=\"text-end\"><strong>{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ additionalProductsTotal | number:'1.2-2':'en-IN' }}</strong></td>\n                        <td></td>\n                    </tr>\n                </tbody>\n            </table>\n        </div>\n    </div>\n\n    <!-- Search + Filter Row -->\n    <div class=\"card-header paymenthistory border-0 px-0\">\n        <div class=\"card-toolbar\">\n            <div class=\"d-flex align-items-center justify-content-between flex-wrap gap-2 w-100\">\n                <div class=\"d-flex align-items-center position-relative my-1\">\n                    <span class=\"svg-icon invoicesearch svg-icon-1 position-absolute mt-6 ms-3\">\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\n                            <path\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\n                                fill=\"currentColor\"></path>\n                        </svg>\n                    </span>\n                    <input [(ngModel)]=\"len\" type=\"text\" class=\"form-control ps-14 invoicesearch\"\n                        placeholder=\"Store name or ID...\" autocomplete=\"off\" (change)=\"searchField()\"\n                        [disabled]=\"searchDisabled\" />\n                    <lib-filters *ngIf=\"filtersReady\" [dataObject]=\"storeFilterObject\" (appliedFilters)=\"applyStoreFilters($event)\"></lib-filters>\n                </div>\n                <button type=\"button\" (click)=\"onExport()\"\n                    class=\"btn-outline btn align-items-end text-nowrap invheader\"\n                    [disabled]=\"!storeList.length\">\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 20 20\" fill=\"none\">\n                        <path d=\"M17.5 12.5V15.8333C17.5 16.2754 17.3244 16.6993 17.0118 17.0118C16.6993 17.3244 16.2754 17.5 15.8333 17.5H4.16667C3.72464 17.5 3.30072 17.3244 2.98816 17.0118C2.67559 16.6993 2.5 16.2754 2.5 15.8333V12.5M14.1667 6.66667L10 2.5M10 2.5L5.83333 6.66667M10 2.5V12.5\"\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                    </svg>\n                    <span class=\"ms-1\">Export</span>\n                </button>\n            </div>\n        </div>\n    </div>\n\n    <!-- Loading Shimmer -->\n    <ng-container *ngIf=\"storeLoading\">\n        <div class=\"row loader d-flex justify-content-center align-items-center\">\n            <div class=\"shimmer\">\n                <div class=\"wrapper\">\n                    <div class=\"stroke animate title\"></div>\n                    <div class=\"stroke animate link\"></div>\n                    <div class=\"stroke animate description\"></div>\n                </div>\n            </div>\n            <div class=\"shimmer\">\n                <div class=\"wrapper\">\n                    <div class=\"stroke animate title\"></div>\n                    <div class=\"stroke animate link\"></div>\n                    <div class=\"stroke animate description\"></div>\n                </div>\n            </div>\n        </div>\n    </ng-container>\n\n    <!-- No Data -->\n    <ng-container *ngIf=\"storeNoData\">\n        <div class=\"row\">\n            <div class=\"col-lg-12 mb-3\">\n                <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\n                    <img class=\"img-src w-25\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\n                </div>\n            </div>\n        </div>\n    </ng-container>\n\n    <!-- Stores Table -->\n    <div *ngIf=\"!storeLoading && !storeNoData\" class=\"table-responsive\">\n        <table class=\"table accordion table bottom-border text-nowrap\">\n            <thead>\n                <tr>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('storeName')\">STORE NAME\n                        <svg [ngClass]=\"sortColumName === 'storeName' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'storeName' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>STORE ID</th>\n                    <th>COUNTRY</th>\n                    <th>PRODUCTS</th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('trafficCameraCount')\">TRAFFIC CAMERAS\n                        <svg [ngClass]=\"sortColumName === 'trafficCameraCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'trafficCameraCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('zoneCameraCount')\">ZONE CAMERAS\n                        <svg [ngClass]=\"sortColumName === 'zoneCameraCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'zoneCameraCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('zoneCount')\">ZONES\n                        <svg [ngClass]=\"sortColumName === 'zoneCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'zoneCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>FIRST FILE DATE</th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('daysDifference')\">WORKING DAYS\n                        <svg [ngClass]=\"sortColumName === 'daysDifference' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'daysDifference' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>STATUS</th>\n                    <th class=\"text-end\">INVOICE AMOUNT</th>\n                </tr>\n            </thead>\n            <tbody>\n                <tr *ngFor=\"let store of storeList\">\n                    <td>\n                        <div class=\"table-title table-title-primary\">{{ store?.storeName }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.storeId }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.country || '—' }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <span *ngFor=\"let product of store?.products\" class=\"badge badge-light-primary me-1\">\n                                {{ formatProductName(product?.productName) }}\n                            </span>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'trafficCameraCount')\">\n                                    <strong>{{ store?.trafficCameraCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'trafficCameraCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'trafficCameraCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'trafficCameraCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'trafficCameraCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'trafficCameraCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'trafficCameraCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'trafficCameraCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'zoneCameraCount')\">\n                                    <strong>{{ store?.zoneCameraCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'zoneCameraCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'zoneCameraCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'zoneCameraCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'zoneCameraCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'zoneCameraCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'zoneCameraCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'zoneCameraCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'zoneCount')\">\n                                    <strong>{{ store?.zoneCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'zoneCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'zoneCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'zoneCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'zoneCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'zoneCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'zoneCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'zoneCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.edgefirstFileDate ? (store?.edgefirstFileDate | date: 'dd MMM yyyy') : '—' }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\" *ngFor=\"let product of store?.products\">\n                            <div class=\"d-flex align-items-center gap-2 mb-1\">\n                                <span class=\"small text-muted\">{{ formatProductName(product?.productName) }}:</span>\n\n                                <!-- View mode -->\n                                <ng-container *ngIf=\"!isEditing(store?.storeId, product?.productName)\">\n                                    <strong>{{ product?.workingdays || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startEdit(store, product)\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n\n                                <!-- Edit mode -->\n                                <ng-container *ngIf=\"isEditing(store?.storeId, product?.productName)\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingProduct[getEditKey(store?.storeId, product?.productName)]\"\n                                        (keydown.enter)=\"saveWorkingDays(store, product)\"\n                                        (keydown.escape)=\"cancelEdit(store, product)\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveWorkingDays(store, product)\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelEdit(store, product)\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"mt-3\" [ngClass]=\"store?.status === 'active' ? 'badge badge-light-success' : 'badge badge-light-danger'\">\n                            {{ store?.status }}\n                        </div>\n                    </td>\n                    <td class=\"text-end\">\n                        <!-- Per-product breakdown (Traffic: ₹x, Zone: ₹y …) + total. -->\n                        <div *ngFor=\"let b of store?.invoiceBreakdown\" class=\"inv-breakdown-row\">\n                            <span class=\"inv-breakdown-label\">{{ b.label }}:</span>\n                            {{ storeCurrencySymbol(store) }}{{ (b.amount || 0) | number:'1.2-2':'en-IN' }}\n                        </div>\n                        <div class=\"table-title inv-breakdown-total\">\n                            <strong>{{ storeCurrencySymbol(store) }}{{ (store?.invoiceAmount || 0) | number:'1.2-2':'en-IN' }}</strong>\n                        </div>\n                    </td>\n                </tr>\n            </tbody>\n        </table>\n        <div *ngIf=\"!storeLoading && !storeNoData\">\n            <lib-pagination class=\"text-start\" [itemsPerPage]=\"itemsPerPage\" [currentPage]=\"currentPage\"\n                [totalItems]=\"totalItems\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"pageSize\"\n                (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\n        </div>\n    </div>\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daily-pricing.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-billing/src/lib/components/daily-pricing/daily-pricing.component.ts","../../../../../../projects/tango-manage-billing/src/lib/components/daily-pricing/daily-pricing.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, Input, OnInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';\nimport { Subject, takeUntil } from 'rxjs';\nimport { NgbModal } from '@ng-bootstrap/ng-bootstrap';\nimport { BillingService } from '../services/billing.service';\nimport { ToastService } from 'tango-app-ui-shared';\nimport { GenerateInvoiceModalComponent } from './generate-invoice-modal/generate-invoice-modal.component';\nimport { NewStoresModalComponent } from './new-stores-modal/new-stores-modal.component';\n\n@Component({\n  selector: 'lib-daily-pricing',\n  templateUrl: './daily-pricing.component.html',\n  styleUrl: './daily-pricing.component.scss'\n})\nexport class DailyPricingComponent implements OnInit, OnChanges, OnDestroy {\n  private readonly destroy$ = new Subject();\n\n  @Input() clientId: string = '';\n\n  len: any;\n  searchDisabled: boolean = false;\n\n  // Metadata\n  dailyPricingInfo: any = {};\n\n  // Edit tracking: key = 'storeId_productName', value = edited workingdays\n  editingProduct: any = {};\n  // Edit tracking for store-level fields (trafficCameraCount, zoneCameraCount, zoneCount)\n  editingField: any = {};\n\n  // Date filter\n  dateFilter: string = '';\n\n  // Filter — multi-select status. No default: the table opens showing ALL\n  // stores (active + deactive); neither option is pre-checked.\n  statusFilter: string[] = [];\n  // Multi-select country filter (options populated from the API's `countries`).\n  countryFilter: string[] = [];\n  storeFilterObject: any[] = [\n    { Description: 'Status', type: 'multi', Issues: [{ id: 'active', text: 'Active' }, { id: 'deactive', text: 'Deactive' }] },\n  ];\n  // lib-filters snapshots dataObject in its ngOnInit, so the Country group must\n  // be present BEFORE it mounts. We gate the <lib-filters> render on this flag,\n  // flipping it true only once the country options have been built from the API.\n  filtersReady: boolean = false;\n\n  // Monthly Billing Summary — derived from invoice history for the brand.\n  // Newest first; each row carries prior-month deltas for the trend indicator.\n  monthlyBillingSummary: any[] = [];\n  monthlySummaryExpanded: boolean = false;\n\n  // Table\n  storeList: any = [];\n  storeLoading: boolean = true;\n  storeNoData: boolean = false;\n  totalItems: number = 0;\n  pageSize: number = 10;\n  currentPage: number = 1;\n  itemsPerPage: number = 10;\n  paginationSizes = [10, 20, 30];\n  // Default sort: working days (daysDifference), highest first.\n  sortColumName: string = 'daysDifference';\n  sortBy: number = -1;\n  generatingInvoice: boolean = false;\n\n  // Additional (non-standard) products available only for specific clients\n  // (currently clientId 11). Empty for everyone else -> the table is hidden.\n  additionalProducts: any[] = [];\n  additionalProductsCurrency: string = 'inr';\n  // Date (YYYY-MM-DD) of the billing_details snapshot behind the additional\n  // product counts; passed to the export so exports match the displayed cards.\n  additionalProductsDate: string = '';\n\n  // Count + list of stores onboarded this month (first file date in the current\n  // month). The list feeds the \"View Stores\" popup.\n  newlyOnboardedStores: number = 0;\n  newlyOnboardedStoreList: any[] = [];\n\n  constructor(\n    private billingService: BillingService,\n    private changeDetector: ChangeDetectorRef,\n    private toast: ToastService,\n    private modalService: NgbModal\n  ) {}\n\n  ngOnInit(): void {\n    if (this.clientId) {\n      this.loadDailyPricing();\n      this.loadAdditionalProducts();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['clientId'] && !changes['clientId'].firstChange && this.clientId) {\n      this.loadDailyPricing();\n      this.loadAdditionalProducts();\n    }\n  }\n\n  // Grand total across all additional-product rows.\n  get additionalProductsTotal(): number {\n    return (this.additionalProducts || []).reduce((a, p) => a + (Number(p.total) || 0), 0);\n  }\n\n  // Products that have a backend detailed export. Keyed by the product key the\n  // export endpoint understands. Add more as their queries are wired up.\n  private readonly exportableProducts: Record<string, string> = {\n    'eyetest': 'eyetest',\n    'eyetest (additional storage)': 'eyetestadditionalstorage',\n    'planogram': 'planogram',\n    'ai manager': 'aimanager',\n    'vms': 'vms',\n    // 'Run AI' is displayed as 'AI in checklist'; both map to the same export\n    // key so the download works whichever label the API returns.\n    'run ai': 'runai',\n    'ai in checklist': 'runai',\n    'remote optum': 'remoteoptum',\n    // Factory QC (FactoryQC_billing Lambda). Day-scoped: the Lambda takes only\n    // report_date, so this export covers the snapshot date shown on the card\n    // rather than month-to-date like Remote Optum.\n    'factory': 'factory',\n  };\n\n  canExportAdditionalProduct(productName: string): boolean {\n    return !!this.exportableProducts[(productName || '').toLowerCase()];\n  }\n\n  exportAdditionalProduct(productName: string): void {\n    const key = this.exportableProducts[(productName || '').toLowerCase()];\n    if (!key) {\n      return;\n    }\n    // Pass the billing_details snapshot date (YYYY-MM-DD) behind the card counts\n    // so day-scoped exports (VMS / Run AI via Lambda to_date, Remote Optum) match\n    // what's shown. Fall back to today if the backend didn't return a date.\n    const today = new Date();\n    const todayStr = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;\n    const exportDate = this.additionalProductsDate || todayStr;\n    this.billingService.additionalProductExport(this.clientId, key, exportDate)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe({\n        next: (res: ArrayBuffer) => {\n          // A real .xlsx is a zip — its first two bytes are 'PK' (0x50 0x4B).\n          // A 204/empty or JSON error body is NOT, and saving it produces a\n          // \"corrupted\" file. Guard so we only save a genuine workbook.\n          const bytes = res ? new Uint8Array(res) : new Uint8Array();\n          const isXlsx = bytes.length > 1 && bytes[0] === 0x50 && bytes[1] === 0x4b;\n          if (!isXlsx) {\n            this.toast.getErrorToast('No data to export');\n            return;\n          }\n          this.billingService.saveAsExcelFile(res, `${productName}-${this.clientId}`);\n        },\n        error: () => {\n          this.toast.getErrorToast('Export failed');\n        },\n      });\n  }\n\n  // Fetch the additional-products table for this client. Backend returns an\n  // empty list for any client that has none (so the table just won't render).\n  loadAdditionalProducts() {\n    // Send the page's selected date (if any) so the section reflects it.\n    this.billingService.additionalProducts(this.clientId, this.dateFilter || undefined).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (res) => {\n        this.additionalProducts = res?.data?.products || [];\n        this.additionalProductsCurrency = res?.data?.currency || 'inr';\n        this.additionalProductsDate = res?.data?.billingDate || '';\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        this.additionalProducts = [];\n        this.changeDetector.detectChanges();\n      },\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next(true);\n    this.destroy$.complete();\n  }\n\n  loadDailyPricing() {\n    this.searchDisabled = false;\n    this.storeLoading = true;\n    this.storeNoData = false;\n\n    let filters: Record<string, any> = {\n      clientId: this.clientId,\n      limit: this.pageSize,\n      offset: this.currentPage,\n      searchValue: this.len,\n      sortColumName: this.sortColumName,\n      sortBy: this.sortBy,\n      statusFilter: this.statusFilter,\n      countryFilter: this.countryFilter,\n      dateFilter: this.dateFilter || '',\n      export: false\n    };\n\n    this.billingService.latestDailyPricing(filters).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (e) => {\n        // The Monthly Billing Summary comes from invoice history, not the store\n        // rows — apply it regardless of whether the store list is empty, so it\n        // still shows when the filtered store table has no rows.\n        this.monthlyBillingSummary = this.decorateMonthlySummary(e?.data?.monthlyBillingSummary || []);\n        // Newly onboarded count/list is independent of the store table's\n        // filters, so capture it whether or not the filtered store list has rows.\n        this.newlyOnboardedStores = e?.data?.newlyOnboardedStores || 0;\n        this.newlyOnboardedStoreList = e?.data?.newlyOnboardedStoreList || [];\n\n        // Populate the Country filter options from the API's country list (all\n        // client stores). Independent of the filtered store count, so build it\n        // even when the filtered table is empty.\n        this.buildCountryFilterOptions(e?.data?.countries || []);\n\n        if (e?.data?.count) {\n          this.storeLoading = false;\n          this.storeNoData = false;\n          this.storeList = e.data?.data;\n          this.totalItems = e.data?.count;\n\n          this.dailyPricingInfo = {\n            brandName: e.data?.brandName || '',\n            dateString: e.data?.dateString || '',\n            dateISO: e.data?.dateISO || '',\n            activeStores: e.data?.activeStores || 0,\n            accountType: e.data?.accountType || '',\n            status: e.data?.status || '',\n            proRate: e.data?.proRate || '',\n            clientId: e.data?.clientId || ''\n          };\n\n          this.changeDetector.detectChanges();\n        } else {\n          this.storeLoading = false;\n          this.storeNoData = true;\n          this.searchDisabled = true;\n          if (this.len?.length) {\n            this.searchDisabled = false;\n          }\n          this.storeList = [];\n          this.totalItems = 0;\n          this.changeDetector.detectChanges();\n        }\n      },\n      error: () => {\n        this.storeLoading = false;\n        this.storeNoData = true;\n        this.storeList = [];\n        this.totalItems = 0;\n        this.monthlyBillingSummary = [];\n        this.changeDetector.detectChanges();\n      }\n    });\n  }\n\n  onDateFilter(event: any) {\n    this.dateFilter = event?.target?.value || '';\n    this.currentPage = 1;\n    this.loadDailyPricing();\n    // Additional Products reflect the selected date too.\n    this.loadAdditionalProducts();\n  }\n\n  clearDateFilter() {\n    this.dateFilter = '';\n    this.currentPage = 1;\n    this.loadDailyPricing();\n    this.loadAdditionalProducts();\n  }\n\n  searchField() {\n    this.currentPage = 1;\n    this.loadDailyPricing();\n  }\n\n  // Add/refresh the Country group in the filter dropdown from the API's country\n  // list, preserving the current selection (checked). lib-filters snapshots\n  // dataObject only in ngOnInit, so we build the full storeFilterObject here and\n  // then flip filtersReady to mount <lib-filters> once — after which it sees both\n  // Status and Country groups.\n  private buildCountryFilterOptions(countries: string[]) {\n    const list = Array.isArray(countries) ? countries.filter(Boolean) : [];\n    if (list.length) {\n      const selected = new Set(this.countryFilter);\n      const issues = list.map((c) => ({ id: c, text: c, checked: selected.has(c) }));\n      const existing = this.storeFilterObject.find((g) => g.Description === 'Country');\n      if (existing) {\n        existing.Issues = issues;\n      } else {\n        this.storeFilterObject = [...this.storeFilterObject, { Description: 'Country', type: 'multi', Issues: issues }];\n      }\n    }\n    // Mount lib-filters once the first response is in (Status alone if there are\n    // no countries), so it snapshots the full dataObject on init.\n    if (!this.filtersReady) {\n      this.filtersReady = true;\n    }\n  }\n\n  applyStoreFilters(event: any) {\n    // Multi-select Status / Country — lib-filters emits each group's selected\n    // options as an ARRAY under Issues (Apply sets Issues = selectedValuesArray\n    // [index]). Collect every selected id, tolerating array and single-object\n    // shapes.\n    const statuses: string[] = [];\n    const countries: string[] = [];\n    if (event?.length) {\n      event.forEach((element: any) => {\n        const issues = Array.isArray(element.Issues) ? element.Issues : (element.Issues ? [element.Issues] : []);\n        if (element.Description === 'Status') {\n          issues.forEach((i: any) => { if (i?.id) statuses.push(i.id); });\n        } else if (element.Description === 'Country') {\n          issues.forEach((i: any) => { if (i?.id) countries.push(i.id); });\n        }\n      });\n    }\n    this.statusFilter = [...new Set(statuses)];\n    this.countryFilter = [...new Set(countries)];\n    this.currentPage = 1;\n    this.loadDailyPricing();\n  }\n\n  sortData(column: string) {\n    this.sortColumName = column;\n    this.sortBy *= -1;\n    this.changeDetector.detectChanges();\n    this.loadDailyPricing();\n  }\n\n  onPageChange(pageOffset: any) {\n    this.currentPage = parseInt(pageOffset);\n    this.loadDailyPricing();\n  }\n\n  onPageSizeChange(pageSize: any) {\n    this.currentPage = 1;\n    this.pageSize = parseInt(pageSize);\n    this.loadDailyPricing();\n  }\n\n  onExport() {\n    let filters: Record<string, any> = {\n      clientId: this.clientId,\n      searchValue: this.len,\n      sortColumName: this.sortColumName,\n      sortBy: this.sortBy,\n      statusFilter: this.statusFilter,\n      dateFilter: this.dateFilter || '',\n      export: true\n    };\n\n    this.billingService.latestDailyPricingExport(filters).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (res) => {\n        // saveAsTemplate (not saveAsExcelFile) — the latter appends a \"list\"\n        // suffix, which would download this as \"Annexurelist.xlsx\".\n        this.billingService.saveAsTemplate(res, 'Annexure');\n      },\n      error: () => {\n        this.toast.getErrorToast('Something went Wrong..');\n      }\n    });\n  }\n\n  getEditKey(storeId: string, productName: string): string {\n    return `${storeId}_${productName}`;\n  }\n\n  isEditing(storeId: string, productName: string): boolean {\n    return this.editingProduct[this.getEditKey(storeId, productName)] !== undefined;\n  }\n\n  startEdit(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    // Coerce to a number so a 0 / missing value still enters edit mode with a\n    // defined value (undefined would make isEditing() think we're not editing).\n    this.editingProduct[key] = Number(product.workingdays) || 0;\n  }\n\n  cancelEdit(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    delete this.editingProduct[key];\n  }\n\n  saveWorkingDays(store: any, product: any) {\n    const key = this.getEditKey(store.storeId, product.productName);\n    const newValue = Number(this.editingProduct[key]) || 0;\n\n    // Unchanged → just close the editor (compare as numbers so 0 vs \"0\" etc.\n    // don't slip through).\n    if (newValue === (Number(product.workingdays) || 0)) {\n      delete this.editingProduct[key];\n      return;\n    }\n\n    const payload = {\n      clientId: this.clientId,\n      dateString: this.dailyPricingInfo.dateString,\n      storeId: store.storeId,\n      productName: product.productName,\n      workingdays: newValue\n    };\n\n    this.billingService.updateDailyPricingWorkingDays(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: () => {\n        product.workingdays = Number(newValue);\n        delete this.editingProduct[key];\n        this.toast.getPrimaryToast('Working days updated successfully');\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        this.toast.getErrorToast('Failed to update working days');\n      }\n    });\n  }\n\n  getFieldEditKey(storeId: string, fieldName: string): string {\n    return `${storeId}_${fieldName}`;\n  }\n\n  isEditingField(storeId: string, fieldName: string): boolean {\n    return this.editingField[this.getFieldEditKey(storeId, fieldName)] !== undefined;\n  }\n\n  startFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    this.editingField[key] = store[fieldName] || 0;\n  }\n\n  cancelFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    delete this.editingField[key];\n  }\n\n  saveFieldEdit(store: any, fieldName: string) {\n    const key = this.getFieldEditKey(store.storeId, fieldName);\n    const newValue = this.editingField[key];\n\n    if (newValue === store[fieldName]) {\n      delete this.editingField[key];\n      return;\n    }\n\n    const payload = {\n      clientId: this.clientId,\n      dateString: this.dailyPricingInfo.dateString,\n      storeId: store.storeId,\n      fieldName: fieldName,\n      value: Number(newValue)\n    };\n\n    this.billingService.updateDailyPricingStoreField(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: () => {\n        store[fieldName] = Number(newValue);\n        delete this.editingField[key];\n        const fieldLabels: Record<string, string> = { trafficCameraCount: 'Traffic camera count', zoneCameraCount: 'Zone camera count', zoneCount: 'Zone count' };\n        this.toast.getPrimaryToast(`${fieldLabels[fieldName] || fieldName} updated successfully`);\n        this.changeDetector.detectChanges();\n      },\n      error: () => {\n        const errorLabels: Record<string, string> = { trafficCameraCount: 'traffic camera count', zoneCameraCount: 'zone camera count', zoneCount: 'zone count' };\n        this.toast.getErrorToast(`Failed to update ${errorLabels[fieldName] || fieldName}`);\n      }\n    });\n  }\n\n  generateInvoice() {\n    if (!this.clientId) return;\n    // Open the picker first — the user chooses which billing groups to\n    // generate for. Modal closes with { groupIds, outstandingGroupIds }\n    // (or is dismissed = no-op).\n    const modalRef = this.modalService.open(GenerateInvoiceModalComponent, {\n      centered: true, size: 'md', scrollable: true,\n    });\n    modalRef.componentInstance.clientId = this.clientId;\n    modalRef.result.then((result: { groupIds: string[]; outstandingGroupIds: string[] }) => {\n      if (!result || !Array.isArray(result.groupIds) || result.groupIds.length === 0) return;\n      this.runInvoiceGeneration(result.groupIds, result.outstandingGroupIds || []);\n    }).catch(() => {});\n  }\n\n  // Open a popup listing the newly onboarded stores (with first file date).\n  // The list is already loaded with the page, so no extra API call is needed.\n  viewNewStores(): void {\n    if (!this.newlyOnboardedStoreList.length) return;\n    const modalRef = this.modalService.open(NewStoresModalComponent, {\n      centered: true, size: 'lg', scrollable: true,\n    });\n    modalRef.componentInstance.stores = this.newlyOnboardedStoreList;\n    // Needed by the modal's Export button so the sheet is built from the same\n    // client and daily-pricing snapshot the popup is showing.\n    modalRef.componentInstance.clientId = this.clientId;\n    modalRef.componentInstance.dateFilter = this.dateFilter || '';\n  }\n\n  private runInvoiceGeneration(groupIds: string[], outstandingGroupIds: string[] = []): void {\n    this.generatingInvoice = true;\n\n    const payload = {\n      allClient: true,\n      clientList: [this.clientId],\n      groupIds,\n      outstandingGroupIds,\n    };\n\n    this.billingService.createInvoice(payload).pipe(takeUntil(this.destroy$)).subscribe({\n      next: (res: any) => {\n        this.generatingInvoice = false;\n        // A partial batch (some groups written, some refused because an advance\n        // invoice already covers this month) comes back as a success whose\n        // message names the skipped groups — show that instead of the generic\n        // \"generated for N groups\", which would overstate what was created.\n        const msg = typeof res?.message === 'string' ? res.message : '';\n        if (msg.includes('Skipped:')) {\n          this.toast.getErrorToast(msg);\n        } else {\n          this.toast.getPrimaryToast(`Invoice generated for ${groupIds.length} billing group(s)`);\n        }\n        this.changeDetector.detectChanges();\n      },\n      error: (err: any) => {\n        this.generatingInvoice = false;\n        // Surface the backend's exact reason (e.g. \"Advance invoice TINV-… already\n        // covers Aug 2026 … Cancel it before generating a new advance invoice.\")\n        // instead of a generic failure.\n        // sendError() puts the text under `error`; `message` is kept as a fallback.\n        this.toast.getErrorToast(err?.error?.error || err?.error?.message || 'Failed to generate invoice');\n        this.changeDetector.detectChanges();\n      }\n    });\n  }\n\n  formatProductName(name: string): string {\n    if (!name) return '';\n    return name.replace(/([a-z])([A-Z])/g, '$1 $2')\n      .replace(/^./, (str) => str.toUpperCase());\n  }\n\n  // Take the raw aggregation rows (already sorted newest-first by the API) and\n  // attach (a) a human-readable monthLabel, (b) tag for the latest two rows\n  // (\"Current\" / \"Last generated\") and (c) deltas vs the immediately older\n  // Currency symbol for a store's invoice amount (matches the backend's\n  // basepricing currency; AED rendered as text).\n  storeCurrencySymbol(store: any): string {\n    const symbols: Record<string, string> = { inr: '₹', dollar: '$', singaporedollar: 'S$', euro: '€', aed: 'AED ' };\n    return symbols[(store?.invoiceCurrency || 'inr').toLowerCase()] || '₹';\n  }\n\n  // month so the template can render the ▲/▼/▬ trend indicators.\n  private decorateMonthlySummary(rows: any[]): any[] {\n    if (!Array.isArray(rows) || rows.length === 0) return [];\n    const monthNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];\n    const symbols: Record<string, string> = { inr: '₹', dollar: '$', singaporedollar: 'S$', euro: '€' };\n    const now = new Date();\n    const isCurrent = (r: any) => r.year === now.getFullYear() && r.month === (now.getMonth() + 1);\n    return rows.map((r, i) => {\n      const next = rows[i + 1];\n      const storesDelta = next ? (r.storesBilled || 0) - (next.storesBilled || 0) : null;\n      const amountDelta = next ? (r.invoiceAmount || 0) - (next.invoiceAmount || 0) : null;\n      let tag = '';\n      if (isCurrent(r)) tag = 'Current';\n      else if (i === 0) tag = 'Last generated';\n      else if (i === 1 && isCurrent(rows[0])) tag = 'Last generated';\n      return {\n        ...r,\n        monthLabel: `${monthNames[(r.month || 1) - 1]} ${r.year}`,\n        tag,\n        storesDelta,\n        amountDelta,\n        currencySymbol: symbols[(r.currency || 'inr').toLowerCase()] || '',\n      };\n    });\n  }\n\n  toggleMonthlySummaryHistory(): void {\n    this.monthlySummaryExpanded = !this.monthlySummaryExpanded;\n  }\n}","<div class=\"invoices-section\">\n    <!-- Header Row -->\n    <div class=\"d-flex justify-content-between align-items-center mb-3\">\n        <div>\n            <div class=\"d-flex align-items-center gap-2\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\n                    <path d=\"M6.66667 10H13.3333M6.66667 6.66667H13.3333M6.66667 13.3333H10M5 17.5H15C15.9205 17.5 16.6667 16.7538 16.6667 15.8333V4.16667C16.6667 3.24619 15.9205 2.5 15 2.5H5C4.07953 2.5 3.33333 3.24619 3.33333 4.16667V15.8333C3.33333 16.7538 4.07953 17.5 5 17.5Z\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                </svg>\n                <span class=\"billingheader\">Billing Breakdown</span>\n                <span class=\"badge bg-light text-dark ms-1\">{{ totalItems }} stores</span>\n            </div>\n            <div class=\"text-muted small mt-1\" *ngIf=\"dailyPricingInfo?.dateString\">\n                Date: <strong>{{ dailyPricingInfo?.dateString }}</strong>\n                <span class=\"mx-2\">|</span>\n                Active Stores: <strong>{{ dailyPricingInfo?.activeStores }}</strong>\n                <span class=\"mx-2\">|</span>\n                Account Type: <strong>{{ dailyPricingInfo?.accountType }}</strong>\n            </div>\n        </div>\n        <div class=\"d-flex align-items-center gap-3\">\n            <div class=\"d-flex align-items-center gap-2\">\n                <input type=\"date\" class=\"form-control form-control-sm date-filter\"\n                    [value]=\"dateFilter\"\n                    (change)=\"onDateFilter($event)\"\n                    placeholder=\"Filter by date\">\n                <button *ngIf=\"dateFilter\" type=\"button\" class=\"btn btn-sm btn-outline-secondary\"\n                    (click)=\"clearDateFilter()\" title=\"Clear date filter\">\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                        <path d=\"M10.5 3.5L3.5 10.5M3.5 3.5L10.5 10.5\" stroke=\"#667085\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                    </svg>\n                </button>\n            </div>\n            <button type=\"button\" (click)=\"generateInvoice()\"\n                class=\"btn btn-primary align-items-end text-nowrap invheader\"\n                [disabled]=\"!storeList.length || generatingInvoice\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 20 20\" fill=\"none\">\n                    <path d=\"M6.66667 10H13.3333M6.66667 6.66667H13.3333M6.66667 13.3333H10M5 17.5H15C15.9205 17.5 16.6667 16.7538 16.6667 15.8333V4.16667C16.6667 3.24619 15.9205 2.5 15 2.5H5C4.07953 2.5 3.33333 3.24619 3.33333 4.16667V15.8333C3.33333 16.7538 4.07953 17.5 5 17.5Z\"\n                        stroke=\"#fff\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                </svg>\n                <span class=\"ms-1\">{{ generatingInvoice ? 'Generating...' : 'Generate Invoice' }}</span>\n            </button>\n        </div>\n    </div>\n\n    <!-- Newly Onboarded Stores — stores whose first file date is in the current month -->\n    <div class=\"d-flex mb-4\">\n        <div class=\"newly-onboarded-card\"\n            style=\"display:flex;align-items:center;gap:14px;border:1px solid #E4E7EC;border-radius:10px;padding:14px 18px;background:#fff;min-width:240px;\">\n            <div style=\"width:40px;height:40px;border-radius:8px;background:#EAF8FF;display:flex;align-items:center;justify-content:center;\">\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"22\" height=\"22\" viewBox=\"0 0 24 24\" fill=\"none\">\n                    <path d=\"M3 21V8l9-5 9 5v13M3 21h18M3 21H1m20 0h2M9 21v-6h6v6M12 7.5h.01\" stroke=\"#00A3FF\" stroke-width=\"1.6\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                </svg>\n            </div>\n            <div>\n                <div style=\"font-size:24px;font-weight:700;color:#101828;line-height:1.1;\">{{ newlyOnboardedStores | number:'1.0-0':'en-IN' }}</div>\n                <div style=\"font-size:13px;color:#667085;\">Newly Onboarded Stores</div>\n                <div style=\"font-size:11px;color:#98A2B3;\">First file in current month</div>\n            </div>\n            <button type=\"button\" class=\"btn btn-sm btn-outline-primary ms-3\"\n                [disabled]=\"!newlyOnboardedStores\"\n                (click)=\"viewNewStores()\">View Stores</button>\n        </div>\n    </div>\n\n    <!-- Monthly Billing Summary — invoice trend (newest first, with deltas vs prior month) -->\n    <div class=\"monthly-billing-summary\" *ngIf=\"monthlyBillingSummary?.length\">\n        <div class=\"msum-header\">Monthly Billing Summary</div>\n        <div class=\"table-responsive\">\n            <table class=\"table mb-0\">\n                <thead>\n                    <tr>\n                        <th>MONTH</th>\n                        <th>NUMBER OF STORES BILLED</th>\n                        <th>INVOICE AMOUNT</th>\n                    </tr>\n                </thead>\n                <tbody>\n                    <ng-container *ngFor=\"let row of monthlyBillingSummary; let i = index\">\n                        <tr *ngIf=\"i < 2 || monthlySummaryExpanded\" [class.curr]=\"row.tag === 'Current'\">\n                            <td>\n                                <strong>{{ row.monthLabel }}</strong>\n                                <span *ngIf=\"row.tag === 'Current'\" class=\"badge badge-light-primary ms-2\">Current</span>\n                                <span *ngIf=\"row.tag === 'Last generated'\" class=\"badge bg-light text-dark ms-2\">Last generated</span>\n                            </td>\n                            <td>\n                                <strong>{{ row.storesBilled }}</strong>\n                                <span *ngIf=\"row.storesDelta !== null\" class=\"ind ms-2\"\n                                    [class.up]=\"row.storesDelta > 0\"\n                                    [class.down]=\"row.storesDelta < 0\"\n                                    [class.flat]=\"row.storesDelta === 0\">\n                                    <ng-container [ngSwitch]=\"true\">\n                                        <ng-container *ngSwitchCase=\"row.storesDelta > 0\">▲ {{ row.storesDelta }}</ng-container>\n                                        <ng-container *ngSwitchCase=\"row.storesDelta < 0\">▼ {{ -row.storesDelta }}</ng-container>\n                                        <ng-container *ngSwitchDefault>▬ 0</ng-container>\n                                    </ng-container>\n                                </span>\n                            </td>\n                            <td>\n                                <strong>{{ row.currencySymbol }}{{ row.invoiceAmount | number:'1.2-2':'en-IN' }}</strong>\n                                <span *ngIf=\"row.amountDelta !== null\" class=\"ind ms-2\"\n                                    [class.up]=\"row.amountDelta > 0\"\n                                    [class.down]=\"row.amountDelta < 0\"\n                                    [class.flat]=\"row.amountDelta === 0\">\n                                    <ng-container [ngSwitch]=\"true\">\n                                        <ng-container *ngSwitchCase=\"row.amountDelta > 0\">▲ {{ row.currencySymbol }}{{ row.amountDelta | number:'1.2-2':'en-IN' }}</ng-container>\n                                        <ng-container *ngSwitchCase=\"row.amountDelta < 0\">▼ {{ row.currencySymbol }}{{ -row.amountDelta | number:'1.2-2':'en-IN' }}</ng-container>\n                                        <ng-container *ngSwitchDefault>▬ 0</ng-container>\n                                    </ng-container>\n                                </span>\n                            </td>\n                        </tr>\n                    </ng-container>\n                </tbody>\n            </table>\n        </div>\n        <div *ngIf=\"monthlyBillingSummary.length > 2\" class=\"msum-toggle\" (click)=\"toggleMonthlySummaryHistory()\">\n            <ng-container *ngIf=\"!monthlySummaryExpanded\">▾ Show older months ({{ monthlyBillingSummary.length - 2 }})</ng-container>\n            <ng-container *ngIf=\"monthlySummaryExpanded\">▴ Hide older months</ng-container>\n        </div>\n    </div>\n\n    <!-- Additional Products — non-standard products billed for this client only\n         (e.g. clientId 11: Eyetest, Planogram). Hidden when the client has none. -->\n    <div class=\"monthly-billing-summary\" *ngIf=\"additionalProducts?.length\">\n        <div class=\"msum-header\">Additional Products</div>\n        <div class=\"table-responsive\">\n            <table class=\"table mb-0\">\n                <thead>\n                    <tr>\n                        <th>Product Name</th>\n                        <th class=\"text-end\">Quantity</th>\n                        <th class=\"text-end\">Price</th>\n                        <th class=\"text-end\">Total</th>\n                        <th class=\"text-center\">Action</th>\n                    </tr>\n                </thead>\n                <tbody>\n                    <tr *ngFor=\"let p of additionalProducts\">\n                        <td>{{ p.productName }}</td>\n                        <td class=\"text-end\">{{ p.quantity | number:'1.0-0':'en-IN' }}</td>\n                        <td class=\"text-end\">{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ p.price | number:'1.2-2':'en-IN' }}</td>\n                        <td class=\"text-end\"><strong>{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ p.total | number:'1.2-2':'en-IN' }}</strong></td>\n                        <td class=\"text-center\">\n                            <button type=\"button\" class=\"btn btn-sm btn-outline-primary\"\n                                *ngIf=\"canExportAdditionalProduct(p.productName)\"\n                                (click)=\"exportAdditionalProduct(p.productName)\">\n                                Download\n                            </button>\n                        </td>\n                    </tr>\n                    <tr>\n                        <td colspan=\"3\" class=\"text-end\"><strong>Grand Total</strong></td>\n                        <td class=\"text-end\"><strong>{{ (additionalProductsCurrency === 'dollar' ? '$' : '₹') }}{{ additionalProductsTotal | number:'1.2-2':'en-IN' }}</strong></td>\n                        <td></td>\n                    </tr>\n                </tbody>\n            </table>\n        </div>\n    </div>\n\n    <!-- Search + Filter Row -->\n    <div class=\"card-header paymenthistory border-0 px-0\">\n        <div class=\"card-toolbar\">\n            <div class=\"d-flex align-items-center justify-content-between flex-wrap gap-2 w-100\">\n                <div class=\"d-flex align-items-center position-relative my-1\">\n                    <span class=\"svg-icon invoicesearch svg-icon-1 position-absolute mt-6 ms-3\">\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\n                            <path\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\n                                fill=\"currentColor\"></path>\n                        </svg>\n                    </span>\n                    <input [(ngModel)]=\"len\" type=\"text\" class=\"form-control ps-14 invoicesearch\"\n                        placeholder=\"Store name or ID...\" autocomplete=\"off\" (change)=\"searchField()\"\n                        [disabled]=\"searchDisabled\" />\n                    <lib-filters *ngIf=\"filtersReady\" [dataObject]=\"storeFilterObject\" (appliedFilters)=\"applyStoreFilters($event)\"></lib-filters>\n                </div>\n                <button type=\"button\" (click)=\"onExport()\"\n                    class=\"btn-outline btn align-items-end text-nowrap invheader\"\n                    [disabled]=\"!storeList.length\">\n                    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 20 20\" fill=\"none\">\n                        <path d=\"M17.5 12.5V15.8333C17.5 16.2754 17.3244 16.6993 17.0118 17.0118C16.6993 17.3244 16.2754 17.5 15.8333 17.5H4.16667C3.72464 17.5 3.30072 17.3244 2.98816 17.0118C2.67559 16.6993 2.5 16.2754 2.5 15.8333V12.5M14.1667 6.66667L10 2.5M10 2.5L5.83333 6.66667M10 2.5V12.5\"\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                    </svg>\n                    <span class=\"ms-1\">Export</span>\n                </button>\n            </div>\n        </div>\n    </div>\n\n    <!-- Loading Shimmer -->\n    <ng-container *ngIf=\"storeLoading\">\n        <div class=\"row loader d-flex justify-content-center align-items-center\">\n            <div class=\"shimmer\">\n                <div class=\"wrapper\">\n                    <div class=\"stroke animate title\"></div>\n                    <div class=\"stroke animate link\"></div>\n                    <div class=\"stroke animate description\"></div>\n                </div>\n            </div>\n            <div class=\"shimmer\">\n                <div class=\"wrapper\">\n                    <div class=\"stroke animate title\"></div>\n                    <div class=\"stroke animate link\"></div>\n                    <div class=\"stroke animate description\"></div>\n                </div>\n            </div>\n        </div>\n    </ng-container>\n\n    <!-- No Data -->\n    <ng-container *ngIf=\"storeNoData\">\n        <div class=\"row\">\n            <div class=\"col-lg-12 mb-3\">\n                <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\n                    <img class=\"img-src w-25\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\n                </div>\n            </div>\n        </div>\n    </ng-container>\n\n    <!-- Stores Table -->\n    <div *ngIf=\"!storeLoading && !storeNoData\" class=\"table-responsive\">\n        <table class=\"table accordion table bottom-border text-nowrap\">\n            <thead>\n                <tr>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('storeName')\">STORE NAME\n                        <svg [ngClass]=\"sortColumName === 'storeName' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'storeName' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>STORE ID</th>\n                    <th>COUNTRY</th>\n                    <th>PRODUCTS</th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('trafficCameraCount')\">TRAFFIC CAMERAS\n                        <svg [ngClass]=\"sortColumName === 'trafficCameraCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'trafficCameraCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('zoneCameraCount')\">ZONE CAMERAS\n                        <svg [ngClass]=\"sortColumName === 'zoneCameraCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'zoneCameraCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('zoneCount')\">ZONES\n                        <svg [ngClass]=\"sortColumName === 'zoneCount' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'zoneCount' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>FIRST FILE DATE</th>\n                    <th class=\"cursor-pointer\" (click)=\"sortData('daysDifference')\">WORKING DAYS\n                        <svg [ngClass]=\"sortColumName === 'daysDifference' && sortBy === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                            <path d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\n                                [attr.stroke]=\"sortColumName === 'daysDifference' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                        </svg>\n                    </th>\n                    <th>STATUS</th>\n                    <th class=\"text-end\">INVOICE AMOUNT</th>\n                </tr>\n            </thead>\n            <tbody>\n                <tr *ngFor=\"let store of storeList\">\n                    <td>\n                        <div class=\"table-title table-title-primary\">{{ store?.storeName }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.storeId }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.country || '—' }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <span *ngFor=\"let product of store?.products\" class=\"badge badge-light-primary me-1\">\n                                {{ formatProductName(product?.productName) }}\n                            </span>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'trafficCameraCount')\">\n                                    <strong>{{ store?.trafficCameraCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'trafficCameraCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'trafficCameraCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'trafficCameraCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'trafficCameraCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'trafficCameraCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'trafficCameraCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'trafficCameraCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'zoneCameraCount')\">\n                                    <strong>{{ store?.zoneCameraCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'zoneCameraCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'zoneCameraCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'zoneCameraCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'zoneCameraCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'zoneCameraCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'zoneCameraCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'zoneCameraCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">\n                            <div class=\"d-flex align-items-center gap-2\">\n                                <ng-container *ngIf=\"!isEditingField(store?.storeId, 'zoneCount')\">\n                                    <strong>{{ store?.zoneCount || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startFieldEdit(store, 'zoneCount')\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                                <ng-container *ngIf=\"isEditingField(store?.storeId, 'zoneCount')\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingField[getFieldEditKey(store?.storeId, 'zoneCount')]\"\n                                        (keydown.enter)=\"saveFieldEdit(store, 'zoneCount')\"\n                                        (keydown.escape)=\"cancelFieldEdit(store, 'zoneCount')\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveFieldEdit(store, 'zoneCount')\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelFieldEdit(store, 'zoneCount')\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\">{{ store?.edgefirstFileDate ? (store?.edgefirstFileDate | date: 'dd MMM yyyy') : '—' }}</div>\n                    </td>\n                    <td>\n                        <div class=\"table-title\" *ngFor=\"let product of store?.products\">\n                            <div class=\"d-flex align-items-center gap-2 mb-1\">\n                                <span class=\"small text-muted\">{{ formatProductName(product?.productName) }}:</span>\n\n                                <!-- View mode -->\n                                <ng-container *ngIf=\"!isEditing(store?.storeId, product?.productName)\">\n                                    <strong>{{ product?.workingdays || 0 }}</strong>\n                                    <span class=\"cursor-pointer edit-icon\" (click)=\"startEdit(store, product)\" title=\"Edit\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\">\n                                            <path d=\"M9.91667 1.75004C10.0698 1.59683 10.2518 1.47533 10.4519 1.39238C10.6522 1.30946 10.8667 1.26679 11.0833 1.26679C11.3 1.26679 11.5145 1.30946 11.7148 1.39238C11.9149 1.47533 12.0969 1.59683 12.25 1.75004C12.4032 1.90325 12.5247 2.08529 12.6077 2.28546C12.6906 2.48567 12.7333 2.70013 12.7333 2.91671C12.7333 3.13329 12.6906 3.34775 12.6077 3.54796C12.5247 3.74813 12.4032 3.93017 12.25 4.08338L4.375 11.9584L1.16667 12.8334L2.04167 9.62504L9.91667 1.75004Z\" stroke=\"#667085\" stroke-width=\"1.16\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n\n                                <!-- Edit mode -->\n                                <ng-container *ngIf=\"isEditing(store?.storeId, product?.productName)\">\n                                    <input type=\"number\" class=\"form-control form-control-sm edit-input\"\n                                        [(ngModel)]=\"editingProduct[getEditKey(store?.storeId, product?.productName)]\"\n                                        (keydown.enter)=\"saveWorkingDays(store, product)\"\n                                        (keydown.escape)=\"cancelEdit(store, product)\">\n                                    <span class=\"cursor-pointer text-success\" (click)=\"saveWorkingDays(store, product)\" title=\"Save\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M13.3334 4L6.00008 11.3333L2.66675 8\" stroke=\"#12B76A\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                    <span class=\"cursor-pointer text-danger\" (click)=\"cancelEdit(store, product)\" title=\"Cancel\">\n                                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\n                                            <path d=\"M12 4L4 12M4 4L12 12\" stroke=\"#F04438\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n                                        </svg>\n                                    </span>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </td>\n                    <td>\n                        <div class=\"mt-3\" [ngClass]=\"store?.status === 'active' ? 'badge badge-light-success' : 'badge badge-light-danger'\">\n                            {{ store?.status }}\n                        </div>\n                    </td>\n                    <td class=\"text-end\">\n                        <!-- Per-product breakdown (Traffic: ₹x, Zone: ₹y …) + total. -->\n                        <div *ngFor=\"let b of store?.invoiceBreakdown\" class=\"inv-breakdown-row\">\n                            <span class=\"inv-breakdown-label\">{{ b.label }}:</span>\n                            {{ storeCurrencySymbol(store) }}{{ (b.amount || 0) | number:'1.2-2':'en-IN' }}\n                        </div>\n                        <div class=\"table-title inv-breakdown-total\">\n                            <strong>{{ storeCurrencySymbol(store) }}{{ (store?.invoiceAmount || 0) | number:'1.2-2':'en-IN' }}</strong>\n                        </div>\n                    </td>\n                </tr>\n            </tbody>\n        </table>\n        <div *ngIf=\"!storeLoading && !storeNoData\">\n            <lib-pagination class=\"text-start\" [itemsPerPage]=\"itemsPerPage\" [currentPage]=\"currentPage\"\n                [totalItems]=\"totalItems\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"pageSize\"\n                (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\n        </div>\n    </div>\n</div>"]}