tango-app-ui-analyse-zone 3.7.1-beta.2 → 3.7.1-beta.20

package/esm2022/lib/components/segmentation/segmentation.component.mjs

@@ -1,5 +1,5 @@
 import { Component, EventEmitter, Output } from '@angular/core';
-import { Subject, debounceTime, skip, takeUntil } from 'rxjs';
+import { Subject, debounceTime, skip, startWith, takeUntil } from 'rxjs';
 import * as am5 from "@amcharts/amcharts5";
 import * as am5xy from "@amcharts/amcharts5/xy";
 import * as i0 from "@angular/core";
@@ -40,27 +40,54 @@ export class SegmentationComponent {
             .pipe(takeUntil(this.destroy$), debounceTime(300))
             .subscribe((data) => {
             this.headerData = data;
-            if (this.headerData?.client === '430') {
-                this.getCardData1();
-                this.getCardData3();
-                this.getCardData();
-                this.getCardData4();
-                this.getCardData5();
-                if (this.ZoneService?.zoneSegmentation) {
-                    this.ZoneService.zoneSegmentation
-                        .pipe(skip(1), takeUntil(this.destroy$)) // Skip the initial emission
-                        .subscribe((zoneData) => {
-                        this.zoneName = zoneData;
-                        this.getCardData4();
-                        this.getCardData5();
+            switch (this.headerData?.client) {
+                case '430':
+                    // First source: getData$
+                    this.ZoneService.getData$()
+                        .pipe(startWith(null), // 👈 fallback seed emission
+                    skip(1), // skip service's initial seed (keep fallback)
+                    takeUntil(this.destroy$))
+                        .subscribe((res) => {
+                        if (res) {
+                            this.zoneName = res;
+                            this.loadClient430Data();
+                        }
+                        else {
+                            this.loadClient430Data();
+                        }
                     });
-                }
-            }
-            else if (this.headerData?.client === '463') {
-                this.getCardData();
+                    // Second source: zoneSegmentation
+                    if (this.ZoneService?.zoneSegmentation) {
+                        this.ZoneService.zoneSegmentation
+                            .pipe(skip(1), takeUntil(this.destroy$))
+                            .subscribe((zoneData) => {
+                            this.zoneName = zoneData;
+                            this.getCardData4();
+                            this.getCardData5();
+                        });
+                    }
+                    break;
+                case '463':
+                    this.loadClient463Data();
+                    break;
+                default:
+                    // handle other clients if needed
+                    break;
             }
         });
     }
+    // Helper for client=430
+    loadClient430Data() {
+        this.getCardData1();
+        this.getCardData3();
+        this.getCardData();
+        this.getCardData4();
+        this.getCardData5();
+    }
+    // Helper for client=463
+    loadClient463Data() {
+        this.getCardData();
+    }
     root;
     ngOnDestroy() {
         if (this.root) {
@@ -454,4 +481,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
         }], ctorParameters: () => [{ type: i1.ZoneService }, { type: i0.ChangeDetectorRef }, { type: i2.GlobalStateService }, { type: i3.ToastService }], propDecorators: { dataEmitter: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"segmentation.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-analyse-zone/src/lib/components/segmentation/segmentation.component.ts","../../../../../../projects/tango-analyse-zone/src/lib/components/segmentation/segmentation.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\r\nimport { ZoneService } from '../services/zone.service';\r\nimport { GlobalStateService } from 'tango-app-ui-global';\r\nimport { Subject, debounceTime, skip, takeUntil} from 'rxjs';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\nimport * as am5 from \"@amcharts/amcharts5\";\r\nimport * as am5xy from \"@amcharts/amcharts5/xy\";\r\n\r\n@Component({\r\n  selector: 'lib-segmentation',\r\n  templateUrl: './segmentation.component.html',\r\n  styleUrl: './segmentation.component.scss'\r\n})\r\n\r\nexport class SegmentationComponent  implements OnInit, OnDestroy{\r\n  cardData: any = {};\r\n  cardDataLoading: boolean = true;\r\n  cardNoData: boolean = false;\r\n  cardDataLoading1: boolean = true;\r\n  cardNoData1: boolean = false;\r\n  cardDataLoading3: boolean = true;\r\n  cardNoData3: boolean = false;\r\n  cardDataLoading4: boolean = true;\r\n  cardNoData4: boolean = false;\r\n  cardDataLoading5: boolean = true;\r\n  cardNoData5: boolean = false;\r\n  headerData: any;\r\n  isExport: boolean = false;\r\n  private destroy$ = new Subject<void>();\r\n  zoneName:any='Overall Store';\r\n  constructor(private ZoneService: ZoneService,private changeDetector: ChangeDetectorRef,public gs: GlobalStateService,private toast: ToastService) {}\r\n  @Output() dataEmitter = new EventEmitter<string>();\r\n  ngOnInit(): void {\r\n    this.gs.dataRangeValue\r\n    .pipe(takeUntil(this.destroy$), debounceTime(300))\r\n    .subscribe((data: any) => {\r\n        this.headerData = data;\r\n        if (this.headerData?.client === '430') {\r\n          this.getCardData1();\r\n          this.getCardData3();\r\n          this.getCardData();\r\n          this.getCardData4();\r\n          this.getCardData5();\r\n           if (this.ZoneService?.zoneSegmentation) {\r\n                    this.ZoneService.zoneSegmentation\r\n                      .pipe(skip(1),takeUntil(this.destroy$)) // Skip the initial emission\r\n                      .subscribe((zoneData: any) => {\r\n                        this.zoneName = zoneData;\r\n                        this.getCardData4();\r\n                        this.getCardData5();\r\n                      });\r\n                  }\r\n                \r\n        } else if (this.headerData?.client === '463') {\r\n          this.getCardData();\r\n        }\r\n        \r\n})\r\n  }\r\n private root!: am5.Root;\r\n  ngOnDestroy(): void {\r\n    if (this.root) {\r\n      this.root.dispose();\r\n    }\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n  }\r\n  getCardData(): void {\r\n    this.cardDataLoading = true;\r\n    this.cardNoData = true;\r\n    const requestData = {\r\n      fromDate: this.headerData.date.startDate,\r\n      toDate: this.headerData.date.endDate,\r\n      storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n      clientId: this.headerData.client,\r\n      export: false,\r\n    };\r\n  \r\n    this.ZoneService.getSegmentationData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n      this.cardDataLoading = false;\r\n      if (response?.code === 200 && response?.status === \"success\") {\r\n        this.cardData = response.data.segmentationAnalysis\r\n        // this.cardData = response.data.segmentationAnalysis.map((item: any) => ({\r\n        //   name: item.category,\r\n        //   value: item.value,\r\n        //   concentrationRate: item.concentrationRate\r\n        // }));\r\n        this.cardNoData = this.cardData.length === 0;\r\n      } else {\r\n        this.cardData = [];\r\n        this.cardNoData = true;\r\n      }\r\n      // this.dataEmitter.emit(this.cardData?.length);\r\n    },\r\n    error => {\r\n      this.cardData = [];\r\n      this.cardNoData = true;\r\n      this.changeDetector.detectChanges();\r\n    });\r\n  }\r\n  onExport() {\r\n    const requestData = {\r\n      fromDate: this.headerData.date.startDate,\r\n      toDate: this.headerData.date.endDate,\r\n      storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n      clientId: this.headerData.client,\r\n      export: true,\r\n    };\r\n\r\n    this.ZoneService.getSegmentationDataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n      next: (res) => {\r\n        this.ZoneService.saveAsExcelFile(res, 'TrafficSegmentation');\r\n      },\r\n      error: (e) => {\r\n        this.toast.getErrorToast('Something went Wrong..')\r\n      }\r\n    })\r\n  }\r\n\r\n  cardData1:any=[];\r\n    getCardData1(): void {\r\n      this.cardDataLoading1 = true;\r\n      this.cardNoData1 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: false,\r\n      };\r\n    \r\n      this.ZoneService.getInterationTable430Data(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading1 = false;\r\n        if (response?.code === 200 && response?.status === \"success\") {\r\n          this.cardData1 = response.data.data\r\n          this.cardNoData1 = this.cardData1.length === 0;\r\n          setTimeout(() => {\r\n            this.createChart(this.cardData1); // Call this method after data is set\r\n          }, 200);\r\n          // this.createChart(this.cardData);\r\n        } else {\r\n          this.cardData1 = [];\r\n          this.cardNoData1 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData1 = [];\r\n        this.cardNoData1 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n    \r\n  \r\n    createChart(cardData1: any[]): void {\r\n      setTimeout(() => {\r\n        const chartDiv = document.getElementById(\"chartdiv\");\r\n        if (!chartDiv) {\r\n          console.error(\"Could not find HTML element with id `chartdiv`\");\r\n          return;\r\n        }\r\n    \r\n        if (this.root) {\r\n          this.root.dispose();\r\n        }\r\n    \r\n        this.root = am5.Root.new('chartdiv');\r\n    \r\n        const chart = this.root.container.children.push(\r\n          am5xy.XYChart.new(this.root, {\r\n            panX: false,\r\n            panY: false,\r\n            paddingLeft: 0,\r\n            wheelX: \"panX\",\r\n            wheelY: \"zoomX\",\r\n            layout: this.root.verticalLayout\r\n          })\r\n        );\r\n    \r\n        const legend = chart.children.push(\r\n          am5.Legend.new(this.root, {\r\n            centerX: am5.p50,\r\n            x: am5.p50\r\n          })\r\n        );\r\n    \r\n        const data: ChartData[] = cardData1.map((item: any) => ({\r\n          year: item.store_name,\r\n          customerCountOver10Min: item.customer_count_over10min,\r\n          customerCountLessThanMin: item.customer_count_lessthanamin\r\n        }));\r\n    \r\n        const xRenderer = am5xy.AxisRendererX.new(this.root, {\r\n          cellStartLocation: 0.1,\r\n          cellEndLocation: 0.9,\r\n          minorGridEnabled: true\r\n        });\r\n    \r\n        const xAxis = chart.xAxes.push(\r\n          am5xy.CategoryAxis.new(this.root, {\r\n            categoryField: \"year\",\r\n            renderer: xRenderer,\r\n            tooltip: am5.Tooltip.new(this.root, {})\r\n          })\r\n        );\r\n    \r\n        xRenderer.grid.template.setAll({\r\n          location: 1\r\n        });\r\n    \r\n        xAxis.data.setAll(data);\r\n    \r\n        xAxis.get(\"renderer\").labels.template.setAll({\r\n          visible: false\r\n        });\r\n    \r\n        const yAxis = chart.yAxes.push(\r\n          am5xy.ValueAxis.new(this.root, {\r\n            renderer: am5xy.AxisRendererY.new(this.root, {\r\n              strokeOpacity: 0.1\r\n            })\r\n          })\r\n        );\r\n    \r\n        // Use an arrow function to ensure `this` is bound correctly\r\n        const makeSeries = (name: string, fieldName: keyof ChartData): void => {\r\n          const series = chart.series.push(am5xy.ColumnSeries.new(this.root, {\r\n            name: name,\r\n            xAxis: xAxis,\r\n            yAxis: yAxis,\r\n            valueYField: fieldName,\r\n            categoryXField: \"year\"\r\n          }));\r\n    \r\n          series.columns.template.setAll({\r\n            tooltipText: \"{name}: {valueY}\",\r\n            width: am5.percent(90),\r\n            tooltipY: 0,\r\n            strokeOpacity: 0\r\n          });\r\n    \r\n          series.data.setAll(data);\r\n          series.appear();\r\n    \r\n          series.bullets.push(() => {\r\n            return am5.Bullet.new(this.root, {\r\n              locationY: 0,\r\n              sprite: am5.Label.new(this.root, {\r\n                text: \"{valueY}\",\r\n                fill: this.root.interfaceColors.get(\"alternativeText\"),\r\n                centerY: 0,\r\n                centerX: am5.p50,\r\n                populateText: true\r\n              })\r\n            });\r\n          });\r\n    \r\n          legend.data.push(series);\r\n        };\r\n    \r\n        makeSeries(\"Customer spent more than 10 mins\", \"customerCountOver10Min\");\r\n        makeSeries(\"Billing Conversion\", \"customerCountLessThanMin\");\r\n    \r\n        chart.appear(1000, 100);\r\n      }, 100);\r\n    }\r\n    \r\n    onExport1() {\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getInterationTable430DataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'CustomerFunnel');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    onRateExport() {\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.zoneInteractionTableExport_430(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'InteractionvsConversion');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    cardData3:any=[]\r\n    getCardData3(): void {\r\n      this.cardDataLoading3 = true;\r\n      this.cardNoData3 = true;\r\n      const requestData = {\r\n        search: this.searchInput3,\r\n        sort: this.sortColumName,\r\n        sortBy: this.sortDirection,\r\n        limit: this.itemsPerPage3,\r\n        offset: this.currentPage3,\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        export: false,\r\n      };\r\n    \r\n      this.ZoneService.getPasserByTable430Data(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading3 = false;\r\n        if (response?.code === 200 && response?.status === \"success\") {\r\n          this.cardData3 = response?.data?.passerByData\r\n          this.cardNoData3 = this.cardData3.length === 0;\r\n        } else {\r\n          this.cardData3 = [];\r\n          this.cardNoData3 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData3 = [];\r\n        this.cardNoData3 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n    onExport3() {\r\n      const requestData = {\r\n        search: this.searchInput3,\r\n        // sort: this.sortColumName,\r\n        // sortBy: this.sortDirection,\r\n        limit: this.itemsPerPage3,\r\n        offset: this.currentPage3,\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store.checked)\r\n          .map((store: any) => store.storeId),\r\n        clientId: this.headerData?.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getPasserByTable430DataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Passer-by Analysis ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    sortColumName: string = '';\r\n    sortBy: any = '';\r\n    sortDirection: any = '';\r\n    itemsPerPage3 = 10000\r\n    currentPage3 = 0\r\n    totalItems3 = 0\r\n    searchInput3:any =''\r\n    sortData(column: string): void {\r\n      if (this.sortColumName === column) {\r\n        this.sortDirection = this.sortDirection === 1 ? -1 : 1;\r\n      } else {\r\n        this.sortColumName = column;\r\n        this.sortDirection = 1;\r\n      }\r\n      this.getCardData3();\r\n    }\r\n\r\n    cardData4:any=[]\r\n    getCardData4(): void {\r\n      this.cardDataLoading4 = true;\r\n      this.cardNoData4 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:false\r\n      };\r\n    \r\n      this.ZoneService.getInteractionTableData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading4 = false;\r\n        if (response?.code === 200 && response) {\r\n          this.cardData4 = response?.data?.customerinteraction_data;\r\n          this.cardData4.total = response?.data?.total;\r\n          this.cardNoData4 = this.cardData4.length === 0;\r\n        } else {\r\n          this.cardData4 = [];\r\n          this.cardNoData4 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData4 = [];\r\n        this.cardNoData4 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n\r\n    onExport4() {\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getInteractionTable430Export(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Interaction Analysis ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n\r\n    cardData5:any=[];\r\n    getCardData5(): void {\r\n      this.cardDataLoading5 = true;\r\n      this.cardNoData5 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:false\r\n      };\r\n    \r\n      this.ZoneService.getZonewiseCustomerFunnelData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading5 = false;\r\n        if (response?.code === 200 && response) {\r\n          this.cardData5 = response?.data?.data;\r\n          this.cardNoData5 = this.cardData5.length === 0;\r\n        } else {\r\n          this.cardData5 = [];\r\n          this.cardNoData5 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData5 = [];\r\n        this.cardNoData5 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n\r\n    onExport5() {\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:true\r\n      };\r\n    \r\n  \r\n      this.ZoneService.getZonewiseCustomerFunnelExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Zonewise Customer Funnel ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n}\r\ninterface ChartData {\r\n  year: string;  // or store name, depending on your requirement\r\n  customerCountOver10Min: number;\r\n  customerCountLessThanMin: number;\r\n}\r\n","<div class=\"row\" >\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData && (headerData?.client === '430') || (!cardNoData && headerData?.client === '463')\">\r\n    <div class=\"card\">\r\n      <div class=\"card-header border-0  px-4\">\r\n        <div class=\"card-title align-items-start  headtext p-3\">Traffic Segmentation <span class=\"ms-1\"\r\n            ngbTooltip=\"Entrance level traffic segmentation\"\r\n            placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n            tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                <g clip-path=\"url(#clip0_3512_32868)\">\r\n                <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                </g>\r\n                <defs>\r\n                <clipPath id=\"clip0_3512_32868\">\r\n                <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                </clipPath>\r\n                </defs>\r\n                </svg></span></div>\r\n        <div class=\"card-toolbar\">\r\n          <div class=\"d-flex\">\r\n            <div class=\"d-flex align-items-center position-relative my-1\">\r\n              <button type=\"button\" (click)=\"onExport()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData.length\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg>\r\n                <span class=\"ms-2\">Export</span>\r\n              </button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n       \r\n\r\n        <div class=\"card-body mb-18 p-0\">\r\n            <div class=\"mx-3 agerangescroll\">\r\n                <table *ngIf=\"!cardDataLoading && !cardNoData\" class=\"table bottom-border\">\r\n                    <thead class=\"fixed-header\">\r\n                      <tr>\r\n                        <th>Entrance</th>\r\n                        <th>Entrance wise footfall</th>\r\n                        <th *ngIf=\"headerData?.client === '463'\">Concentration Rate</th>\r\n                        \r\n                      </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-responsive\">\r\n                      <tr *ngFor=\"let item of cardData\">\r\n                        <td>{{ item.category }}</td>\r\n                        <td>{{ item.value?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }}</td>\r\n                        <td *ngIf=\"headerData?.client === '463'\">{{ item.concentrationRate?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }} %</td>\r\n                      </tr>\r\n                      </tbody>\r\n                  </table>\r\n                  \r\n                <ng-container *ngIf=\"cardDataLoading\">\r\n                    <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                        <div class=\"shimmer my-17\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"cardNoData && !cardDataLoading\">\r\n                    <div class=\"row\">\r\n                        <div class=\"col-lg-12\">\r\n                            <div\r\n                                class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                                <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                                <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                                <div class=\"nodatasubtext\">There is no result for Age Analysis</div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData1 && headerData?.client === '430'\" >\r\n  <div class=\"card\">\r\n    <div class=\"card-header border-0 p-2\">\r\n      <div class=\"card-title align-items-start  headtext p-3\">Customer Funnel <span class=\"ms-1\"\r\n        ngbTooltip=\"Summary of walk-in behaviour from passerby to conversion at the store\"\r\n        placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n        tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n            <g clip-path=\"url(#clip0_3512_32868)\">\r\n            <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n            </g>\r\n            <defs>\r\n            <clipPath id=\"clip0_3512_32868\">\r\n            <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n            </clipPath>\r\n            </defs>\r\n            </svg></span></div>\r\n      <div class=\"card-toolbar\">\r\n        <div class=\"d-flex\">\r\n          <div class=\"d-flex align-items-center position-relative my-1\">\r\n            <button type=\"button\" (click)=\"onExport1()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData1.length\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n              </svg>\r\n              <span class=\"ms-2\">Export</span>\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <!-- overflowfunnel -->\r\n    <div  *ngIf=\"!cardDataLoading1 && !cardNoData1\" class=\"body me-4\">\r\n      <div *ngFor=\"let item of cardData1\" class=\"m-4\">\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Passer By\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.passer_by || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Footfall\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.footfall || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Drop In Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.drop_in_rate || '--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Greetings Count\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.greeting_count || '--' }}\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n        <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Greetings Rate\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ ((item.greeting_count / item.footfall) * 100).toFixed(1) || '--' }}%\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Customer Interacted\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.customer_attended || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Interaction Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <!-- <span class=\"table-title\">{{ roundof(overallStoreData?.concentrationRate) ||  '0' }} %</span> -->\r\n                  <span class=\"table-title\">{{ item.interaction_rate || '--' }} %</span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Avg Time Taken to Assist a Customer\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.avg_interaction_time_string || '--' }}\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_time_taken) }} -->\r\n                </span>\r\n            </div>\r\n        </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Avg Time Spent with Customer\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.assist_time_string || '--' }}\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_interaction_time) }} -->\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Billing Conversion\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.footfall_overamin_inzone !== null ? item.footfall_overamin_inzone : '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Billing Conversion Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.billing_conversion_rate  !== null ? item.billing_conversion_rate :'--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n      \r\n\r\n         \r\n      </div>\r\n  \r\n      </div>\r\n      <div>\r\n      <ng-container *ngIf=\"cardDataLoading1\">\r\n          <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n              <div class=\"shimmer my-17\">\r\n                  <div class=\"wrapper\">\r\n                      <div class=\"stroke animate title\"></div>\r\n                      <div class=\"stroke animate link\"></div>\r\n                      <div class=\"stroke animate description\"></div>\r\n                  </div>\r\n              </div>\r\n          </div>\r\n      </ng-container>\r\n      <ng-container *ngIf=\"cardNoData1 && !cardDataLoading1\">\r\n          <div class=\"row\">\r\n              <div class=\"col-lg-12\">\r\n                  <div\r\n                      class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                      <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                      <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                      <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                  </div>\r\n              </div>\r\n          </div>\r\n      </ng-container>\r\n  </div>\r\n     \r\n\r\n      <!-- <div class=\"card-body p-0\">\r\n          <div class=\"mx-3 agerangescroll\">\r\n              <table *ngIf=\"!cardDataLoading && !cardNoData\" class=\"table bottom-border\">\r\n                  <thead class=\"fixed-header\">\r\n                    <tr>\r\n                     \r\n                      <th>Interaction Rate</th>\r\n                      <th>Customer Attended</th>\r\n                      <th>Passer By</th>\r\n                    \r\n                      <th>Drop In Rate</th>\r\n                      <th>Billing Conversion</th>\r\n                      <th>Footfall</th>\r\n                    </tr>\r\n                  </thead>\r\n                  <tbody class=\"table-responsive\">\r\n                      <tr *ngFor=\"let item of cardData\">\r\n                       \r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.interaction_rate }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.customer_attended }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.passer_by }}</div>\r\n                        </td>\r\n                       \r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.zonename }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.drop_in_rate }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.footfall_overamin_inzone }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.footfall }}</div>\r\n                        </td>\r\n                      </tr>\r\n                    </tbody>\r\n                </table>\r\n                \r\n              <ng-container *ngIf=\"cardDataLoading\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                      <div class=\"shimmer my-17\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData && !cardDataLoading\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n          </div>\r\n      </div> -->\r\n  </div>\r\n</div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData5 && headerData?.client === '430'\" >\r\n    <div class=\"card\">\r\n      <div class=\"card-header border-0 p-2\">\r\n        <div class=\"card-title align-items-start  headtext p-3\">Zonewise Customer Funnel <span class=\"ms-1\"\r\n          ngbTooltip=\"Summary of walk-in behaviour from passerby to conversion at the store\"\r\n          placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n          tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n              <g clip-path=\"url(#clip0_3512_32868)\">\r\n              <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n              </g>\r\n              <defs>\r\n              <clipPath id=\"clip0_3512_32868\">\r\n              <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n              </clipPath>\r\n              </defs>\r\n              </svg></span></div>\r\n        <div class=\"card-toolbar\">\r\n          <div class=\"d-flex\">\r\n            <div class=\"d-flex align-items-center position-relative my-1\">\r\n              <button type=\"button\" (click)=\"onExport5()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData5.length\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg>\r\n                <span class=\"ms-2\">Export</span>\r\n              </button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <!-- overflowfunnel -->\r\n      <div  *ngIf=\"!cardDataLoading5 && !cardNoData5\" class=\"body me-4 mb-8\">\r\n        <div *ngFor=\"let item of cardData5\" class=\"m-4 agerangescroll\">\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Footfall\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.footfall || '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Greetings Count\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.greeting_count || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Greetings Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ ((item.greeting_count / item.footfall) * 100).toFixed(1) || '--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Customer Interacted\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.customer_attended || '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Interaction Rate\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <!-- <span class=\"table-title\">{{ roundof(overallStoreData?.concentrationRate) ||  '0' }} %</span> -->\r\n                    <span class=\"table-title\">{{ item.interaction_rate || '--' }} %</span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Avg Time Taken to Assist a Customer\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.avg_interaction_time_string || '--' }}\r\n                        <!-- {{ convertSecondsToMinSec(item.avg_time_taken) }} -->\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                    Avg Time Spent with Customer\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_interaction_time) }} -->\r\n                      {{ item.assist_time_string || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Billing Conversion\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.footfall_overamin_inzone !== null ? item.footfall_overamin_inzone : '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"borderdashed my-2\"></div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Billing Conversion Rate\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.billing_conversion_rate !== null ? item.billing_conversion_rate + '%' : '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n        \r\n  \r\n           \r\n        </div>\r\n    \r\n        </div>\r\n        <div>\r\n        <ng-container *ngIf=\"cardDataLoading5\">\r\n            <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                <div class=\"shimmer my-17\">\r\n                    <div class=\"wrapper\">\r\n                        <div class=\"stroke animate title\"></div>\r\n                        <div class=\"stroke animate link\"></div>\r\n                        <div class=\"stroke animate description\"></div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n        <ng-container *ngIf=\"cardNoData5 && !cardDataLoading5\">\r\n            <div class=\"row\">\r\n                <div class=\"col-lg-12\">\r\n                    <div\r\n                        class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                        <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                        <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                        <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n    </div>\r\n       \r\n    </div>\r\n  </div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData1 && headerData?.client === '430'\">\r\n      <div class=\"card\">\r\n          <div class=\"card-header border-0 p-2\">\r\n              <div class=\"card-title align-items-start  headtext p-3\">Interaction vs Conversion <span class=\"ms-1\"\r\n                ngbTooltip=\"Comparison of engaged walk-in vs potential conversion in the store\"\r\n                placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n                tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                    <g clip-path=\"url(#clip0_3512_32868)\">\r\n                    <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                    </g>\r\n                    <defs>\r\n                    <clipPath id=\"clip0_3512_32868\">\r\n                    <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                    </clipPath>\r\n                    </defs>\r\n                    </svg></span></div>\r\n              <div class=\"card-toolbar\">\r\n                <div class=\"d-flex\">\r\n                  <div class=\"d-flex align-items-center position-relative my-1\">\r\n                      <!-- [disabled]=\"!cardData.length\" -->\r\n                    <button type=\"button\" (click)=\"onRateExport()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" >\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      <span class=\"ms-2\">Export</span>\r\n                    </button>\r\n                  </div>\r\n                </div>\r\n              </div>\r\n            </div>\r\n            <div class=\"card-body mb-14 p-0\">\r\n              <div *ngIf=\"!cardDataLoading1 && !cardNoData1\" id=\"chartdiv\"></div>\r\n              <ng-container *ngIf=\"cardDataLoading1\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center\">\r\n                      <div class=\"shimmer\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                      <div class=\"shimmer\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n  \r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData1 && !cardDataLoading1\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body mb-13 d-flex justify-content-center align-items-center flex-column\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for Gender Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              </div>\r\n      </div>\r\n</div>\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData3 && headerData?.client === '430'\">\r\n  <div class=\"card\">\r\n    <div class=\"card-header border-0  px-4\">\r\n      <div class=\"card-title align-items-start  headtext p-3\">Passer-by Analysis <span class=\"ms-1\"\r\n        ngbTooltip=\"Summary of camera wise passerby count\"\r\n        placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n        tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n            <g clip-path=\"url(#clip0_3512_32868)\">\r\n            <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n            </g>\r\n            <defs>\r\n            <clipPath id=\"clip0_3512_32868\">\r\n            <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n            </clipPath>\r\n            </defs>\r\n            </svg></span></div>\r\n      <div class=\"card-toolbar\">\r\n        <div class=\"d-flex\">\r\n          <div class=\"d-flex align-items-center position-relative my-1\">\r\n            <button type=\"button\" (click)=\"onExport3()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData3.length\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n              </svg>\r\n              <span class=\"ms-2\">Export</span>\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n     \r\n\r\n      <div class=\"card-body mb-8 p-0\">\r\n          <div class=\"mx-3 agerangescroll\">\r\n              <table *ngIf=\"!cardDataLoading3 && !cardNoData3\" class=\"table bottom-border\">\r\n                  <thead class=\"fixed-header\">\r\n                    <tr>\r\n                      <th><div class=\"cursor-pointer\" (click)=\"sortData('streamName')\">\r\n                          Camera Name\r\n                          <svg  [ngClass]=\"sortColumName === 'streamName' && sortDirection === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\r\n                          fill=\"none\">\r\n                          <path\r\n                              d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\r\n                              [attr.stroke]=\"sortColumName === 'streamName' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                              stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      </div></th>\r\n                      <th><div class=\"cursor-pointer\" (click)=\"sortData('passerby_count')\">\r\n                          Passer-by Count\r\n                          <svg  [ngClass]=\"sortColumName === 'passerby_count' && sortDirection === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\r\n                          fill=\"none\">\r\n                          <path\r\n                              d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\r\n                              [attr.stroke]=\"sortColumName === 'passerby_count' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                              stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      </div></th>\r\n                    </tr>\r\n                  </thead>\r\n                  <tbody class=\"table-responsive\">\r\n                    <tr *ngFor=\"let item of cardData3\">\r\n                      <td class=\"text-capitalize\">{{ item.streamName ? item.streamName :'--'}}</td>\r\n                      <td>{{ item.passerby_count?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }}</td>\r\n                     \r\n                    </tr>\r\n                    </tbody>\r\n                </table>\r\n                \r\n              <ng-container *ngIf=\"cardDataLoading3\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                      <div class=\"shimmer my-17\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData3 && !cardDataLoading3\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for PasserBy Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n          </div>\r\n      </div>\r\n  </div>\r\n</div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData4 && headerData?.client === '430'\">\r\n    <div class=\"card\">\r\n        <div class=\"card-header border-0  px-4\">\r\n            <div class=\"card-title align-items-start  headtext p-3\">Interaction Analysis <span class=\"ms-1\"\r\n                ngbTooltip=\"Time-series analysis of customer interactions\"\r\n                placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n                tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                    <g clip-path=\"url(#clip0_3512_32868)\">\r\n                    <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                    </g>\r\n                    <defs>\r\n                    <clipPath id=\"clip0_3512_32868\">\r\n                    <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                    </clipPath>\r\n                    </defs>\r\n                    </svg></span></div>\r\n                    <div class=\"card-toolbar\">\r\n                        <div class=\"d-flex\">\r\n                          <div class=\"d-flex align-items-center position-relative my-1\">\r\n                            <button type=\"button\" (click)=\"onExport4()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData4.length\">\r\n                              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                              </svg>\r\n                              <span class=\"ms-2\">Export</span>\r\n                            </button>\r\n                          </div>\r\n                        </div>\r\n                      </div>\r\n            </div>\r\n        <div class=\"card-body mb-8 p-0\">\r\n            <div class=\"mx-3 agerangescroll\">\r\n                <table *ngIf=\"!cardDataLoading4 && !cardNoData4\" class=\"table bottom-border\">\r\n                    <thead class=\"fixed-header\">\r\n                        <tr>\r\n                            <th>Category</th>\r\n                            <th>Value</th>\r\n                        </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-responsive\">\r\n                        <tr *ngFor=\"let item of cardData4\">\r\n                            <td>\r\n                                    {{ item.category }}\r\n                            </td>\r\n                            <td>\r\n                                <div class=\"row\">\r\n                                    <div class=\"col-6 mt-2\">\r\n                                        <ngb-progressbar class=\"mb-3\" height=\"10px\" type=\"primary\" [value]=\"item?.value\" [max]=\"cardData4?.total\" />\r\n                                    </div>\r\n                                    <div class=\"col-6\">\r\n                                        {{ item?.value?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--'}}\r\n                                        \r\n                                    </div>\r\n                                </div>\r\n                            </td>\r\n                        </tr>\r\n                    </tbody>\r\n                </table>\r\n                <ng-container *ngIf=\"cardDataLoading4\">\r\n                    <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                        <div class=\"shimmer my-17\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div>\r\n                        <!-- <div class=\"shimmer\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div> -->\r\n    \r\n                    </div>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"cardNoData4 && !cardDataLoading4\">\r\n                    <div class=\"row\">\r\n                        <div class=\"col-lg-12\">\r\n                            <div\r\n                                class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                                <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                                <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                                <div class=\"nodatasubtext\">There is no result for Interaction Analysis</div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"segmentation.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-analyse-zone/src/lib/components/segmentation/segmentation.component.ts","../../../../../../projects/tango-analyse-zone/src/lib/components/segmentation/segmentation.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, EventEmitter, Input, OnDestroy, OnInit, Output } from '@angular/core';\r\nimport { ZoneService } from '../services/zone.service';\r\nimport { GlobalStateService } from 'tango-app-ui-global';\r\nimport { Subject, debounceTime, skip, startWith, takeUntil} from 'rxjs';\r\nimport { ToastService } from 'tango-app-ui-shared';\r\nimport * as am5 from \"@amcharts/amcharts5\";\r\nimport * as am5xy from \"@amcharts/amcharts5/xy\";\r\n\r\n@Component({\r\n  selector: 'lib-segmentation',\r\n  templateUrl: './segmentation.component.html',\r\n  styleUrl: './segmentation.component.scss'\r\n})\r\n\r\nexport class SegmentationComponent  implements OnInit, OnDestroy{\r\n  cardData: any = {};\r\n  cardDataLoading: boolean = true;\r\n  cardNoData: boolean = false;\r\n  cardDataLoading1: boolean = true;\r\n  cardNoData1: boolean = false;\r\n  cardDataLoading3: boolean = true;\r\n  cardNoData3: boolean = false;\r\n  cardDataLoading4: boolean = true;\r\n  cardNoData4: boolean = false;\r\n  cardDataLoading5: boolean = true;\r\n  cardNoData5: boolean = false;\r\n  headerData: any;\r\n  isExport: boolean = false;\r\n  private destroy$ = new Subject<void>();\r\n  zoneName:any='Overall Store';\r\n  constructor(private ZoneService: ZoneService,private changeDetector: ChangeDetectorRef,public gs: GlobalStateService,private toast: ToastService) {}\r\n  @Output() dataEmitter = new EventEmitter<string>();\r\n ngOnInit(): void {\r\n  this.gs.dataRangeValue\r\n    .pipe(takeUntil(this.destroy$), debounceTime(300))\r\n    .subscribe((data: any) => {\r\n      this.headerData = data;\r\n\r\n      switch (this.headerData?.client) {\r\n        case '430':\r\n          // First source: getData$\r\n            this.ZoneService.getData$()\r\n                  .pipe(\r\n                    startWith(null), // 👈 fallback seed emission\r\n                    skip(1),         // skip service's initial seed (keep fallback)\r\n                    takeUntil(this.destroy$)\r\n                  )\r\n                  .subscribe((res: any) => {\r\n                    if (res) {\r\n                      this.zoneName = res;\r\n                      this.loadClient430Data();\r\n                    } else {\r\n       \r\n              this.loadClient430Data();\r\n            }\r\n          })\r\n\r\n          // Second source: zoneSegmentation\r\n          if (this.ZoneService?.zoneSegmentation) {\r\n            this.ZoneService.zoneSegmentation\r\n              .pipe(skip(1), takeUntil(this.destroy$))\r\n              .subscribe((zoneData: any) => {\r\n                this.zoneName = zoneData;\r\n                this.getCardData4();\r\n                this.getCardData5();\r\n              });\r\n          }\r\n          break;\r\n\r\n        case '463':\r\n          this.loadClient463Data();\r\n          break;\r\n\r\n        default:\r\n          // handle other clients if needed\r\n          break;\r\n      }\r\n    });\r\n}\r\n\r\n// Helper for client=430\r\nprivate loadClient430Data() {\r\n  this.getCardData1();\r\n  this.getCardData3();\r\n  this.getCardData();\r\n  this.getCardData4();\r\n  this.getCardData5();\r\n}\r\n\r\n// Helper for client=463\r\nprivate loadClient463Data() {\r\n  this.getCardData();\r\n}\r\n\r\n private root!: am5.Root;\r\n  ngOnDestroy(): void {\r\n    if (this.root) {\r\n      this.root.dispose();\r\n    }\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n  }\r\n  getCardData(): void {\r\n    this.cardDataLoading = true;\r\n    this.cardNoData = true;\r\n    const requestData = {\r\n      fromDate: this.headerData.date.startDate,\r\n      toDate: this.headerData.date.endDate,\r\n      storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n      clientId: this.headerData.client,\r\n      export: false,\r\n    };\r\n  \r\n    this.ZoneService.getSegmentationData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n      this.cardDataLoading = false;\r\n      if (response?.code === 200 && response?.status === \"success\") {\r\n        this.cardData = response.data.segmentationAnalysis\r\n        // this.cardData = response.data.segmentationAnalysis.map((item: any) => ({\r\n        //   name: item.category,\r\n        //   value: item.value,\r\n        //   concentrationRate: item.concentrationRate\r\n        // }));\r\n        this.cardNoData = this.cardData.length === 0;\r\n      } else {\r\n        this.cardData = [];\r\n        this.cardNoData = true;\r\n      }\r\n      // this.dataEmitter.emit(this.cardData?.length);\r\n    },\r\n    error => {\r\n      this.cardData = [];\r\n      this.cardNoData = true;\r\n      this.changeDetector.detectChanges();\r\n    });\r\n  }\r\n  onExport() {\r\n    const requestData = {\r\n      fromDate: this.headerData.date.startDate,\r\n      toDate: this.headerData.date.endDate,\r\n      storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n      clientId: this.headerData.client,\r\n      export: true,\r\n    };\r\n\r\n    this.ZoneService.getSegmentationDataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n      next: (res) => {\r\n        this.ZoneService.saveAsExcelFile(res, 'TrafficSegmentation');\r\n      },\r\n      error: (e) => {\r\n        this.toast.getErrorToast('Something went Wrong..')\r\n      }\r\n    })\r\n  }\r\n\r\n  cardData1:any=[];\r\n    getCardData1(): void {\r\n      this.cardDataLoading1 = true;\r\n      this.cardNoData1 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: false,\r\n      };\r\n    \r\n      this.ZoneService.getInterationTable430Data(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading1 = false;\r\n        if (response?.code === 200 && response?.status === \"success\") {\r\n          this.cardData1 = response.data.data\r\n          this.cardNoData1 = this.cardData1.length === 0;\r\n          setTimeout(() => {\r\n            this.createChart(this.cardData1); // Call this method after data is set\r\n          }, 200);\r\n          // this.createChart(this.cardData);\r\n        } else {\r\n          this.cardData1 = [];\r\n          this.cardNoData1 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData1 = [];\r\n        this.cardNoData1 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n    \r\n  \r\n    createChart(cardData1: any[]): void {\r\n      setTimeout(() => {\r\n        const chartDiv = document.getElementById(\"chartdiv\");\r\n        if (!chartDiv) {\r\n          console.error(\"Could not find HTML element with id `chartdiv`\");\r\n          return;\r\n        }\r\n    \r\n        if (this.root) {\r\n          this.root.dispose();\r\n        }\r\n    \r\n        this.root = am5.Root.new('chartdiv');\r\n    \r\n        const chart = this.root.container.children.push(\r\n          am5xy.XYChart.new(this.root, {\r\n            panX: false,\r\n            panY: false,\r\n            paddingLeft: 0,\r\n            wheelX: \"panX\",\r\n            wheelY: \"zoomX\",\r\n            layout: this.root.verticalLayout\r\n          })\r\n        );\r\n    \r\n        const legend = chart.children.push(\r\n          am5.Legend.new(this.root, {\r\n            centerX: am5.p50,\r\n            x: am5.p50\r\n          })\r\n        );\r\n    \r\n        const data: ChartData[] = cardData1.map((item: any) => ({\r\n          year: item.store_name,\r\n          customerCountOver10Min: item.customer_count_over10min,\r\n          customerCountLessThanMin: item.customer_count_lessthanamin\r\n        }));\r\n    \r\n        const xRenderer = am5xy.AxisRendererX.new(this.root, {\r\n          cellStartLocation: 0.1,\r\n          cellEndLocation: 0.9,\r\n          minorGridEnabled: true\r\n        });\r\n    \r\n        const xAxis = chart.xAxes.push(\r\n          am5xy.CategoryAxis.new(this.root, {\r\n            categoryField: \"year\",\r\n            renderer: xRenderer,\r\n            tooltip: am5.Tooltip.new(this.root, {})\r\n          })\r\n        );\r\n    \r\n        xRenderer.grid.template.setAll({\r\n          location: 1\r\n        });\r\n    \r\n        xAxis.data.setAll(data);\r\n    \r\n        xAxis.get(\"renderer\").labels.template.setAll({\r\n          visible: false\r\n        });\r\n    \r\n        const yAxis = chart.yAxes.push(\r\n          am5xy.ValueAxis.new(this.root, {\r\n            renderer: am5xy.AxisRendererY.new(this.root, {\r\n              strokeOpacity: 0.1\r\n            })\r\n          })\r\n        );\r\n    \r\n        // Use an arrow function to ensure `this` is bound correctly\r\n        const makeSeries = (name: string, fieldName: keyof ChartData): void => {\r\n          const series = chart.series.push(am5xy.ColumnSeries.new(this.root, {\r\n            name: name,\r\n            xAxis: xAxis,\r\n            yAxis: yAxis,\r\n            valueYField: fieldName,\r\n            categoryXField: \"year\"\r\n          }));\r\n    \r\n          series.columns.template.setAll({\r\n            tooltipText: \"{name}: {valueY}\",\r\n            width: am5.percent(90),\r\n            tooltipY: 0,\r\n            strokeOpacity: 0\r\n          });\r\n    \r\n          series.data.setAll(data);\r\n          series.appear();\r\n    \r\n          series.bullets.push(() => {\r\n            return am5.Bullet.new(this.root, {\r\n              locationY: 0,\r\n              sprite: am5.Label.new(this.root, {\r\n                text: \"{valueY}\",\r\n                fill: this.root.interfaceColors.get(\"alternativeText\"),\r\n                centerY: 0,\r\n                centerX: am5.p50,\r\n                populateText: true\r\n              })\r\n            });\r\n          });\r\n    \r\n          legend.data.push(series);\r\n        };\r\n    \r\n        makeSeries(\"Customer spent more than 10 mins\", \"customerCountOver10Min\");\r\n        makeSeries(\"Billing Conversion\", \"customerCountLessThanMin\");\r\n    \r\n        chart.appear(1000, 100);\r\n      }, 100);\r\n    }\r\n    \r\n    onExport1() {\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getInterationTable430DataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'CustomerFunnel');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    onRateExport() {\r\n      const requestData = {\r\n        fromDate: this.headerData.date.startDate,\r\n        toDate: this.headerData.date.endDate,\r\n        storeId: this.headerData.stores.filter((store: any) => store.checked).map((store: any) => store.storeId),\r\n        clientId: this.headerData.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.zoneInteractionTableExport_430(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'InteractionvsConversion');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    cardData3:any=[]\r\n    getCardData3(): void {\r\n      this.cardDataLoading3 = true;\r\n      this.cardNoData3 = true;\r\n      const requestData = {\r\n        search: this.searchInput3,\r\n        sort: this.sortColumName,\r\n        sortBy: this.sortDirection,\r\n        limit: this.itemsPerPage3,\r\n        offset: this.currentPage3,\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        export: false,\r\n      };\r\n    \r\n      this.ZoneService.getPasserByTable430Data(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading3 = false;\r\n        if (response?.code === 200 && response?.status === \"success\") {\r\n          this.cardData3 = response?.data?.passerByData\r\n          this.cardNoData3 = this.cardData3.length === 0;\r\n        } else {\r\n          this.cardData3 = [];\r\n          this.cardNoData3 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData3 = [];\r\n        this.cardNoData3 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n    onExport3() {\r\n      const requestData = {\r\n        search: this.searchInput3,\r\n        // sort: this.sortColumName,\r\n        // sortBy: this.sortDirection,\r\n        limit: this.itemsPerPage3,\r\n        offset: this.currentPage3,\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store.checked)\r\n          .map((store: any) => store.storeId),\r\n        clientId: this.headerData?.client,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getPasserByTable430DataExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Passer-by Analysis ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n    sortColumName: string = '';\r\n    sortBy: any = '';\r\n    sortDirection: any = '';\r\n    itemsPerPage3 = 10000\r\n    currentPage3 = 0\r\n    totalItems3 = 0\r\n    searchInput3:any =''\r\n    sortData(column: string): void {\r\n      if (this.sortColumName === column) {\r\n        this.sortDirection = this.sortDirection === 1 ? -1 : 1;\r\n      } else {\r\n        this.sortColumName = column;\r\n        this.sortDirection = 1;\r\n      }\r\n      this.getCardData3();\r\n    }\r\n\r\n    cardData4:any=[]\r\n    getCardData4(): void {\r\n      this.cardDataLoading4 = true;\r\n      this.cardNoData4 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:false\r\n      };\r\n    \r\n      this.ZoneService.getInteractionTableData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading4 = false;\r\n        if (response?.code === 200 && response) {\r\n          this.cardData4 = response?.data?.customerinteraction_data;\r\n          this.cardData4.total = response?.data?.total;\r\n          this.cardNoData4 = this.cardData4.length === 0;\r\n        } else {\r\n          this.cardData4 = [];\r\n          this.cardNoData4 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData4 = [];\r\n        this.cardNoData4 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n\r\n    onExport4() {\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export: true,\r\n      };\r\n  \r\n      this.ZoneService.getInteractionTable430Export(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Interaction Analysis ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n\r\n    cardData5:any=[];\r\n    getCardData5(): void {\r\n      this.cardDataLoading5 = true;\r\n      this.cardNoData5 = true;\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:false\r\n      };\r\n    \r\n      this.ZoneService.getZonewiseCustomerFunnelData(requestData).pipe(takeUntil(this.destroy$)).subscribe((response: any) => {\r\n        this.cardDataLoading5 = false;\r\n        if (response?.code === 200 && response) {\r\n          this.cardData5 = response?.data?.data;\r\n          this.cardNoData5 = this.cardData5.length === 0;\r\n        } else {\r\n          this.cardData5 = [];\r\n          this.cardNoData5 = true;\r\n        }\r\n      },\r\n      error => {\r\n        this.cardData5 = [];\r\n        this.cardNoData5 = true;\r\n        this.changeDetector.detectChanges();\r\n      });\r\n    }\r\n\r\n    onExport5() {\r\n      const requestData = {\r\n        fromDate: this.headerData?.date?.startDate,\r\n        toDate: this.headerData?.date?.endDate,\r\n        storeId: this.headerData?.stores\r\n          .filter((store: any) => store?.checked)\r\n          .map((store: any) => store?.storeId),\r\n        clientId: this.headerData?.client,\r\n        zoneName: this.zoneName,\r\n        export:true\r\n      };\r\n    \r\n  \r\n      this.ZoneService.getZonewiseCustomerFunnelExport(requestData).pipe(takeUntil(this.destroy$)).subscribe({\r\n        next: (res) => {\r\n          this.ZoneService.saveAsExcelFile(res, 'Zonewise Customer Funnel ');\r\n        },\r\n        error: (e) => {\r\n          this.toast.getErrorToast('Something went Wrong..')\r\n        }\r\n      })\r\n    }\r\n}\r\ninterface ChartData {\r\n  year: string;  // or store name, depending on your requirement\r\n  customerCountOver10Min: number;\r\n  customerCountLessThanMin: number;\r\n}\r\n","<div class=\"row\" >\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData && (headerData?.client === '430') || (!cardNoData && headerData?.client === '463')\">\r\n    <div class=\"card\">\r\n      <div class=\"card-header border-0  px-4\">\r\n        <div class=\"card-title align-items-start  headtext p-3\">Traffic Segmentation <span class=\"ms-1\"\r\n            ngbTooltip=\"Entrance level traffic segmentation\"\r\n            placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n            tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                <g clip-path=\"url(#clip0_3512_32868)\">\r\n                <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                </g>\r\n                <defs>\r\n                <clipPath id=\"clip0_3512_32868\">\r\n                <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                </clipPath>\r\n                </defs>\r\n                </svg></span></div>\r\n        <div class=\"card-toolbar\">\r\n          <div class=\"d-flex\">\r\n            <div class=\"d-flex align-items-center position-relative my-1\">\r\n              <button type=\"button\" (click)=\"onExport()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData.length\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg>\r\n                <span class=\"ms-2\">Export</span>\r\n              </button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n       \r\n\r\n        <div class=\"card-body mb-18 p-0\">\r\n            <div class=\"mx-3 agerangescroll\">\r\n                <table *ngIf=\"!cardDataLoading && !cardNoData\" class=\"table bottom-border\">\r\n                    <thead class=\"fixed-header\">\r\n                      <tr>\r\n                        <th>Entrance</th>\r\n                        <th>Entrance wise footfall</th>\r\n                        <th *ngIf=\"headerData?.client === '463'\">Concentration Rate</th>\r\n                        \r\n                      </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-responsive\">\r\n                      <tr *ngFor=\"let item of cardData\">\r\n                        <td>{{ item.category }}</td>\r\n                        <td>{{ item.value?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }}</td>\r\n                        <td *ngIf=\"headerData?.client === '463'\">{{ item.concentrationRate?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }} %</td>\r\n                      </tr>\r\n                      </tbody>\r\n                  </table>\r\n                  \r\n                <ng-container *ngIf=\"cardDataLoading\">\r\n                    <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                        <div class=\"shimmer my-17\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"cardNoData && !cardDataLoading\">\r\n                    <div class=\"row\">\r\n                        <div class=\"col-lg-12\">\r\n                            <div\r\n                                class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                                <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                                <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                                <div class=\"nodatasubtext\">There is no result for Age Analysis</div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData1 && headerData?.client === '430'\" >\r\n  <div class=\"card\">\r\n    <div class=\"card-header border-0 p-2\">\r\n      <div class=\"card-title align-items-start  headtext p-3\">Customer Funnel <span class=\"ms-1\"\r\n        ngbTooltip=\"Summary of walk-in behaviour from passerby to conversion at the store\"\r\n        placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n        tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n            <g clip-path=\"url(#clip0_3512_32868)\">\r\n            <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n            </g>\r\n            <defs>\r\n            <clipPath id=\"clip0_3512_32868\">\r\n            <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n            </clipPath>\r\n            </defs>\r\n            </svg></span></div>\r\n      <div class=\"card-toolbar\">\r\n        <div class=\"d-flex\">\r\n          <div class=\"d-flex align-items-center position-relative my-1\">\r\n            <button type=\"button\" (click)=\"onExport1()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData1.length\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n              </svg>\r\n              <span class=\"ms-2\">Export</span>\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <!-- overflowfunnel -->\r\n    <div  *ngIf=\"!cardDataLoading1 && !cardNoData1\" class=\"body me-4\">\r\n      <div *ngFor=\"let item of cardData1\" class=\"m-4\">\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Passer By\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.passer_by || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Footfall\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.footfall || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Drop In Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.drop_in_rate || '--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Greetings Count\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.greeting_count || '--' }}\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n        <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Greetings Rate\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ ((item.greeting_count / item.footfall) * 100).toFixed(1) || '--' }}%\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Customer Interacted\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.customer_attended || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Interaction Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <!-- <span class=\"table-title\">{{ roundof(overallStoreData?.concentrationRate) ||  '0' }} %</span> -->\r\n                  <span class=\"table-title\">{{ item.interaction_rate || '--' }} %</span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Avg Time Taken to Assist a Customer\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.avg_interaction_time_string || '--' }}\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_time_taken) }} -->\r\n                </span>\r\n            </div>\r\n        </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n            <span class=\"d-flex flex-row align-items-center\">\r\n                <div class=\"overalltext me-2\">\r\n                    Avg Time Spent with Customer\r\n                </div>\r\n            </span>\r\n            <div class=\"d-flex align-items-center\">\r\n                <span class=\"table-title\">\r\n                    {{ item.assist_time_string || '--' }}\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_interaction_time) }} -->\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Billing Conversion\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.footfall_overamin_inzone !== null ? item.footfall_overamin_inzone : '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Billing Conversion Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.billing_conversion_rate  !== null ? item.billing_conversion_rate :'--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n      \r\n\r\n         \r\n      </div>\r\n  \r\n      </div>\r\n      <div>\r\n      <ng-container *ngIf=\"cardDataLoading1\">\r\n          <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n              <div class=\"shimmer my-17\">\r\n                  <div class=\"wrapper\">\r\n                      <div class=\"stroke animate title\"></div>\r\n                      <div class=\"stroke animate link\"></div>\r\n                      <div class=\"stroke animate description\"></div>\r\n                  </div>\r\n              </div>\r\n          </div>\r\n      </ng-container>\r\n      <ng-container *ngIf=\"cardNoData1 && !cardDataLoading1\">\r\n          <div class=\"row\">\r\n              <div class=\"col-lg-12\">\r\n                  <div\r\n                      class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                      <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                      <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                      <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                  </div>\r\n              </div>\r\n          </div>\r\n      </ng-container>\r\n  </div>\r\n     \r\n\r\n      <!-- <div class=\"card-body p-0\">\r\n          <div class=\"mx-3 agerangescroll\">\r\n              <table *ngIf=\"!cardDataLoading && !cardNoData\" class=\"table bottom-border\">\r\n                  <thead class=\"fixed-header\">\r\n                    <tr>\r\n                     \r\n                      <th>Interaction Rate</th>\r\n                      <th>Customer Attended</th>\r\n                      <th>Passer By</th>\r\n                    \r\n                      <th>Drop In Rate</th>\r\n                      <th>Billing Conversion</th>\r\n                      <th>Footfall</th>\r\n                    </tr>\r\n                  </thead>\r\n                  <tbody class=\"table-responsive\">\r\n                      <tr *ngFor=\"let item of cardData\">\r\n                       \r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.interaction_rate }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.customer_attended }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.passer_by }}</div>\r\n                        </td>\r\n                       \r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.zonename }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.drop_in_rate }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.footfall_overamin_inzone }}</div>\r\n                        </td>\r\n                        <td>\r\n                          <div class=\"table-title subscribedtext\">{{ item.footfall }}</div>\r\n                        </td>\r\n                      </tr>\r\n                    </tbody>\r\n                </table>\r\n                \r\n              <ng-container *ngIf=\"cardDataLoading\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                      <div class=\"shimmer my-17\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData && !cardDataLoading\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n          </div>\r\n      </div> -->\r\n  </div>\r\n</div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData5 && headerData?.client === '430'\" >\r\n    <div class=\"card\">\r\n      <div class=\"card-header border-0 p-2\">\r\n        <div class=\"card-title align-items-start  headtext p-3\">Zonewise Customer Funnel <span class=\"ms-1\"\r\n          ngbTooltip=\"Summary of walk-in behaviour from passerby to conversion at the store\"\r\n          placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n          tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n              <g clip-path=\"url(#clip0_3512_32868)\">\r\n              <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n              </g>\r\n              <defs>\r\n              <clipPath id=\"clip0_3512_32868\">\r\n              <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n              </clipPath>\r\n              </defs>\r\n              </svg></span></div>\r\n        <div class=\"card-toolbar\">\r\n          <div class=\"d-flex\">\r\n            <div class=\"d-flex align-items-center position-relative my-1\">\r\n              <button type=\"button\" (click)=\"onExport5()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData5.length\">\r\n                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                </svg>\r\n                <span class=\"ms-2\">Export</span>\r\n              </button>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <!-- overflowfunnel -->\r\n      <div  *ngIf=\"!cardDataLoading5 && !cardNoData5\" class=\"body me-4 mb-8\">\r\n        <div *ngFor=\"let item of cardData5\" class=\"m-4 agerangescroll\">\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Footfall\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.footfall || '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Greetings Count\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ item.greeting_count || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n          <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                      Greetings Rate\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                      {{ ((item.greeting_count / item.footfall) * 100).toFixed(1) || '--' }}%\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Customer Interacted\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.customer_attended || '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Interaction Rate\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <!-- <span class=\"table-title\">{{ roundof(overallStoreData?.concentrationRate) ||  '0' }} %</span> -->\r\n                    <span class=\"table-title\">{{ item.interaction_rate || '--' }} %</span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Avg Time Taken to Assist a Customer\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.avg_interaction_time_string || '--' }}\r\n                        <!-- {{ convertSecondsToMinSec(item.avg_time_taken) }} -->\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div class=\"borderdashed my-2\"></div>\r\n            <div class=\"d-flex flex-stack\">\r\n              <span class=\"d-flex flex-row align-items-center\">\r\n                  <div class=\"overalltext me-2\">\r\n                    Avg Time Spent with Customer\r\n                  </div>\r\n              </span>\r\n              <div class=\"d-flex align-items-center\">\r\n                  <span class=\"table-title\">\r\n                    <!-- {{ convertSecondsToMinSec(item.avg_interaction_time) }} -->\r\n                      {{ item.assist_time_string || '--' }}\r\n                  </span>\r\n              </div>\r\n          </div>\r\n          <div class=\"borderdashed my-2\"></div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Billing Conversion\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.footfall_overamin_inzone !== null ? item.footfall_overamin_inzone : '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"borderdashed my-2\"></div>\r\n            <div *ngIf=\"zoneName ==='Overall Store'\" class=\"d-flex flex-stack\">\r\n                <span class=\"d-flex flex-row align-items-center\">\r\n                    <div class=\"overalltext me-2\">\r\n                        Billing Conversion Rate\r\n                    </div>\r\n                </span>\r\n                <div class=\"d-flex align-items-center\">\r\n                    <span class=\"table-title\">\r\n                        {{ item.billing_conversion_rate !== null ? item.billing_conversion_rate + '%' : '--' }}\r\n                    </span>\r\n                </div>\r\n            </div>\r\n        \r\n  \r\n           \r\n        </div>\r\n    \r\n        </div>\r\n        <div>\r\n        <ng-container *ngIf=\"cardDataLoading5\">\r\n            <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                <div class=\"shimmer my-17\">\r\n                    <div class=\"wrapper\">\r\n                        <div class=\"stroke animate title\"></div>\r\n                        <div class=\"stroke animate link\"></div>\r\n                        <div class=\"stroke animate description\"></div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n        <ng-container *ngIf=\"cardNoData5 && !cardDataLoading5\">\r\n            <div class=\"row\">\r\n                <div class=\"col-lg-12\">\r\n                    <div\r\n                        class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                        <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                        <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                        <div class=\"nodatasubtext\">There is no result for Interation Table Analysis</div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container>\r\n    </div>\r\n       \r\n    </div>\r\n  </div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData1 && headerData?.client === '430'\">\r\n      <div class=\"card\">\r\n          <div class=\"card-header border-0 p-2\">\r\n              <div class=\"card-title align-items-start  headtext p-3\">Interaction vs Conversion <span class=\"ms-1\"\r\n                ngbTooltip=\"Comparison of engaged walk-in vs potential conversion in the store\"\r\n                placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n                tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                    <g clip-path=\"url(#clip0_3512_32868)\">\r\n                    <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                    </g>\r\n                    <defs>\r\n                    <clipPath id=\"clip0_3512_32868\">\r\n                    <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                    </clipPath>\r\n                    </defs>\r\n                    </svg></span></div>\r\n              <div class=\"card-toolbar\">\r\n                <div class=\"d-flex\">\r\n                  <div class=\"d-flex align-items-center position-relative my-1\">\r\n                      <!-- [disabled]=\"!cardData.length\" -->\r\n                    <button type=\"button\" (click)=\"onRateExport()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" >\r\n                      <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      <span class=\"ms-2\">Export</span>\r\n                    </button>\r\n                  </div>\r\n                </div>\r\n              </div>\r\n            </div>\r\n            <div class=\"card-body mb-14 p-0\">\r\n              <div *ngIf=\"!cardDataLoading1 && !cardNoData1\" id=\"chartdiv\"></div>\r\n              <ng-container *ngIf=\"cardDataLoading1\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center\">\r\n                      <div class=\"shimmer\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                      <div class=\"shimmer\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n  \r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData1 && !cardDataLoading1\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body mb-13 d-flex justify-content-center align-items-center flex-column\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for Gender Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              </div>\r\n      </div>\r\n</div>\r\n\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData3 && headerData?.client === '430'\">\r\n  <div class=\"card\">\r\n    <div class=\"card-header border-0  px-4\">\r\n      <div class=\"card-title align-items-start  headtext p-3\">Passer-by Analysis <span class=\"ms-1\"\r\n        ngbTooltip=\"Summary of camera wise passerby count\"\r\n        placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n        tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n            <g clip-path=\"url(#clip0_3512_32868)\">\r\n            <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n            </g>\r\n            <defs>\r\n            <clipPath id=\"clip0_3512_32868\">\r\n            <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n            </clipPath>\r\n            </defs>\r\n            </svg></span></div>\r\n      <div class=\"card-toolbar\">\r\n        <div class=\"d-flex\">\r\n          <div class=\"d-flex align-items-center position-relative my-1\">\r\n            <button type=\"button\" (click)=\"onExport3()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData3.length\">\r\n              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n              </svg>\r\n              <span class=\"ms-2\">Export</span>\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n     \r\n\r\n      <div class=\"card-body mb-8 p-0\">\r\n          <div class=\"mx-3 agerangescroll\">\r\n              <table *ngIf=\"!cardDataLoading3 && !cardNoData3\" class=\"table bottom-border\">\r\n                  <thead class=\"fixed-header\">\r\n                    <tr>\r\n                      <th><div class=\"cursor-pointer\" (click)=\"sortData('streamName')\">\r\n                          Camera Name\r\n                          <svg  [ngClass]=\"sortColumName === 'streamName' && sortDirection === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\r\n                          fill=\"none\">\r\n                          <path\r\n                              d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\r\n                              [attr.stroke]=\"sortColumName === 'streamName' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                              stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      </div></th>\r\n                      <th><div class=\"cursor-pointer\" (click)=\"sortData('passerby_count')\">\r\n                          Passer-by Count\r\n                          <svg  [ngClass]=\"sortColumName === 'passerby_count' && sortDirection === 1 ? 'rotate' : ''\" xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\"\r\n                          fill=\"none\">\r\n                          <path\r\n                              d=\"M8.00016 3.33337V12.6667M8.00016 12.6667L12.6668 8.00004M8.00016 12.6667L3.3335 8.00004\"\r\n                              [attr.stroke]=\"sortColumName === 'passerby_count' ? '#00A3FF' : '#667085'\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                              stroke-linejoin=\"round\" />\r\n                      </svg>\r\n                      </div></th>\r\n                    </tr>\r\n                  </thead>\r\n                  <tbody class=\"table-responsive\">\r\n                    <tr *ngFor=\"let item of cardData3\">\r\n                      <td class=\"text-capitalize\">{{ item.streamName ? item.streamName :'--'}}</td>\r\n                      <td>{{ item.passerby_count?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--' }}</td>\r\n                     \r\n                    </tr>\r\n                    </tbody>\r\n                </table>\r\n                \r\n              <ng-container *ngIf=\"cardDataLoading3\">\r\n                  <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                      <div class=\"shimmer my-17\">\r\n                          <div class=\"wrapper\">\r\n                              <div class=\"stroke animate title\"></div>\r\n                              <div class=\"stroke animate link\"></div>\r\n                              <div class=\"stroke animate description\"></div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n              <ng-container *ngIf=\"cardNoData3 && !cardDataLoading3\">\r\n                  <div class=\"row\">\r\n                      <div class=\"col-lg-12\">\r\n                          <div\r\n                              class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                              <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                              <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                              <div class=\"nodatasubtext\">There is no result for PasserBy Analysis</div>\r\n                          </div>\r\n                      </div>\r\n                  </div>\r\n              </ng-container>\r\n          </div>\r\n      </div>\r\n  </div>\r\n</div>\r\n<div class=\"col-md-4 mt-2\" *ngIf=\"!cardNoData4 && headerData?.client === '430'\">\r\n    <div class=\"card\">\r\n        <div class=\"card-header border-0  px-4\">\r\n            <div class=\"card-title align-items-start  headtext p-3\">Interaction Analysis <span class=\"ms-1\"\r\n                ngbTooltip=\"Time-series analysis of customer interactions\"\r\n                placement=\"right\" triggers=\"mouseenter:mouseleave\"\r\n                tooltipClass=\"custom-tooltip\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\">\r\n                    <g clip-path=\"url(#clip0_3512_32868)\">\r\n                    <path d=\"M8.00016 10.6666V7.99998M8.00016 5.33331H8.00683M14.6668 7.99998C14.6668 11.6819 11.6821 14.6666 8.00016 14.6666C4.31826 14.6666 1.3335 11.6819 1.3335 7.99998C1.3335 4.31808 4.31826 1.33331 8.00016 1.33331C11.6821 1.33331 14.6668 4.31808 14.6668 7.99998Z\" stroke=\"#98A2B3\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\r\n                    </g>\r\n                    <defs>\r\n                    <clipPath id=\"clip0_3512_32868\">\r\n                    <rect width=\"16\" height=\"16\" fill=\"white\"/>\r\n                    </clipPath>\r\n                    </defs>\r\n                    </svg></span></div>\r\n                    <div class=\"card-toolbar\">\r\n                        <div class=\"d-flex\">\r\n                          <div class=\"d-flex align-items-center position-relative my-1\">\r\n                            <button type=\"button\" (click)=\"onExport4()\" class=\"btn-outline btn align-items-end text-nowrap invheader me-4\" [disabled]=\"!cardData4.length\">\r\n                              <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\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\" stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                              </svg>\r\n                              <span class=\"ms-2\">Export</span>\r\n                            </button>\r\n                          </div>\r\n                        </div>\r\n                      </div>\r\n            </div>\r\n        <div class=\"card-body mb-8 p-0\">\r\n            <div class=\"mx-3 agerangescroll\">\r\n                <table *ngIf=\"!cardDataLoading4 && !cardNoData4\" class=\"table bottom-border\">\r\n                    <thead class=\"fixed-header\">\r\n                        <tr>\r\n                            <th>Category</th>\r\n                            <th>Value</th>\r\n                        </tr>\r\n                    </thead>\r\n                    <tbody class=\"table-responsive\">\r\n                        <tr *ngFor=\"let item of cardData4\">\r\n                            <td>\r\n                                    {{ item.category }}\r\n                            </td>\r\n                            <td>\r\n                                <div class=\"row\">\r\n                                    <div class=\"col-6 mt-2\">\r\n                                        <ngb-progressbar class=\"mb-3\" height=\"10px\" type=\"primary\" [value]=\"item?.value\" [max]=\"cardData4?.total\" />\r\n                                    </div>\r\n                                    <div class=\"col-6\">\r\n                                        {{ item?.value?.toLocaleString('en-US', { minimumFractionDigits: 0 }) || '--'}}\r\n                                        \r\n                                    </div>\r\n                                </div>\r\n                            </td>\r\n                        </tr>\r\n                    </tbody>\r\n                </table>\r\n                <ng-container *ngIf=\"cardDataLoading4\">\r\n                    <div class=\"row loader d-flex justify-content-center align-items-center mb-15\">\r\n                        <div class=\"shimmer my-17\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div>\r\n                        <!-- <div class=\"shimmer\">\r\n                            <div class=\"wrapper\">\r\n                                <div class=\"stroke animate title\"></div>\r\n                                <div class=\"stroke animate link\"></div>\r\n                                <div class=\"stroke animate description\"></div>\r\n                            </div>\r\n                        </div> -->\r\n    \r\n                    </div>\r\n                </ng-container>\r\n                <ng-container *ngIf=\"cardNoData4 && !cardDataLoading4\">\r\n                    <div class=\"row\">\r\n                        <div class=\"col-lg-12\">\r\n                            <div\r\n                                class=\"card-body d-flex justify-content-center align-items-center flex-column mb-10\">\r\n                                <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata1.svg\" alt=\"\">\r\n                                <div class=\"nodatamaintext mt-3\">No data found</div>\r\n                                <div class=\"nodatasubtext\">There is no result for Interaction Analysis</div>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </ng-container>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>\r\n</div>"]}