tango-app-ui-manage-stores 3.0.11-dev → 3.0.13-dev

package/esm2022/lib/components/create-group/create-group.component.mjs

@@ -121,24 +121,35 @@ export class CreateGroupComponent {
                             this.activeModal.close();
                         }
                         else {
+                            this.activeModal.close();
+                            this.ts.getErrorToast('Unable to add Group');
                         }
                     },
-                    error: () => { },
+                    error: () => {
+                        this.activeModal.close();
+                        this.ts.getErrorToast('Unable to add Group');
+                    },
                     complete: () => { },
                 });
             }
         }
         else {
             if (this.groupForm.valid) {
-                this.groupService.updateGroup(this.groupForm.value).subscribe({
+                this.groupService.updateGroup({ ...this.groupForm.value, ...{ clientId: this.$headerFilters.client } }).subscribe({
                     next: (res) => {
                         if (res && res.code == 200) {
                             this.ts.getSuccessToast("Group updated successfully");
+                            this.activeModal.close();
                         }
                         else {
+                            this.activeModal.close();
+                            this.ts.getErrorToast('Unable to update Group');
                         }
                     },
-                    error: () => { },
+                    error: () => {
+                        this.activeModal.close();
+                        this.ts.getErrorToast('Unable to update Group');
+                    },
                     complete: () => { },
                 });
             }
@@ -217,4 +228,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImpor
                 type: HostListener,
                 args: ['document:click', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-group.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/create-group/create-group.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/create-group/create-group.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, HostListener, Input, OnInit } from \"@angular/core\";\r\nimport { FormBuilder, FormGroup, Validators } from \"@angular/forms\";\r\nimport { NgbActiveModal } from \"@ng-bootstrap/ng-bootstrap\";\r\nimport { GroupService } from \"../../services/group.service\";\r\nimport { GlobalStateService, ToastService } from \"tango-app-ui-shared\";\r\n\r\n@Component({\r\n  selector: \"lib-create-group\",\r\n  templateUrl: \"./create-group.component.html\",\r\n  styleUrl: \"./create-group.component.scss\",\r\n})\r\nexport class CreateGroupComponent implements OnInit {\r\n  @Input() type: string;\r\n  @Input() editGroup: any;\r\n\r\n  groupType: string;\r\n  groupForm: FormGroup;\r\n  availableStores: any[];\r\n  selectedValuesArray: any[] = [];\r\n  group: any;\r\n  Opendropdown: boolean;\r\n  dataObject: any[] = [\r\n    { Description: 'Stores', Stores: []},  \r\n  ];\r\n  $headerFilters: any;\r\n  selectedText: string;\r\n\r\n  constructor(\r\n    private activeModal: NgbActiveModal,\r\n    private cd: ChangeDetectorRef,\r\n    private fb: FormBuilder,\r\n    private groupService: GroupService,\r\n    private ts: ToastService,\r\n    private gs: GlobalStateService\r\n  ) {\r\n    this.createForm();\r\n    this.gs.selectedClient.subscribe({\r\n      next: (data: any) => {},\r\n    });\r\n    this.gs.dataRangeValue.subscribe({\r\n      next: (data: any) => {\r\n        this.$headerFilters = data;\r\n        this.getAvailableStores();\r\n      },\r\n    });\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.groupType = this.type;\r\n  }\r\n\r\n  getGroup() {\r\n    this.groupService\r\n      .getGroup({\r\n        clientId: this.editGroup?.clientId,\r\n        groupName: this.editGroup?.groupName,\r\n      })\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          if (res && res.code == 200) {\r\n            this.group = res.data.result;\r\n            this.loadGroup();\r\n          } else {\r\n          }\r\n        },\r\n        error: () => {},\r\n        complete: () => {},\r\n      });\r\n  }\r\n\r\n  loadGroup() {\r\n    this.groupForm = this.fb.group({\r\n      groupName: [this.group?.groupName, Validators.required],\r\n      description: [this.group?.description],\r\n      storeList: [this.group?.storeList, Validators.required],\r\n    });\r\n    this.loadSelectedStores(this.group?.storeList);\r\n  }\r\n\r\n  createForm() {\r\n    this.groupForm = this.fb.group({\r\n      groupName: [\"\", Validators.required],\r\n      description: [\"\"],\r\n      storeList: [[], Validators.required],\r\n    });\r\n  }\r\n\r\n  getAvailableStores() {\r\n    this.groupService.getStores({ clientId: this.$headerFilters.client }).subscribe({\r\n      next: (res: any) => {\r\n        if (res && res.code == 200) {\r\n          this.availableStores = res.data.result;\r\n          this.dataObject[0].Stores = res.data.result;\r\n          this.cd.detectChanges();\r\n          if (this.editGroup) {\r\n            this.getGroup();\r\n          } else {\r\n          }\r\n        } else {\r\n        }\r\n      },\r\n      error: () => { \r\n        this.availableStores = [];\r\n      },\r\n      complete: () => {},\r\n    });\r\n  }\r\n\r\n  cancel() {\r\n    this.activeModal.close();\r\n  }\r\n  editgroup() {\r\n    this.groupType = \"edit\";\r\n  }\r\n\r\n  groupSubmit() {\r\n    if (this.groupType === \"add\") {\r\n      if (this.groupForm.valid) {\r\n        this.groupService\r\n          .createGroup({ ...this.groupForm.value, ...{ clientId: this.$headerFilters.client } })\r\n          .subscribe({\r\n            next: (res: any) => {\r\n              if (res && res.code == 200) {\r\n                this.ts.getSuccessToast(\"Group added successfully\");\r\n                this.activeModal.close();\r\n              } else {\r\n              }\r\n            },\r\n            error: () => {},\r\n            complete: () => {},\r\n          });\r\n      }\r\n    } else {\r\n      if (this.groupForm.valid) {\r\n        this.groupService.updateGroup(this.groupForm.value).subscribe({\r\n          next: (res: any) => {\r\n            if (res && res.code == 200) {\r\n              this.ts.getSuccessToast(\"Group updated successfully\");\r\n            } else {\r\n            }\r\n          },\r\n          error: () => {},\r\n          complete: () => {},\r\n        });\r\n      }\r\n    }\r\n  }\r\n  \r\n  @HostListener('document:click', ['$event'])\r\n  onClick(event: MouseEvent) {\r\n    const\r\n      target = event.target as HTMLElement;\r\n    if (!target.closest('.dropdown1')) {\r\n      this.Opendropdown = false;\r\n    }\r\n    if (!target.closest('.dropdown-content')) {\r\n      this.dataObject.forEach((item: any, i: any) => {\r\n        item.isOpen = false;\r\n      }\r\n      );\r\n    }\r\n  }\r\n \r\n  opendropdown(e: MouseEvent) {\r\n    e.stopPropagation();\r\n    this.Opendropdown = !this.Opendropdown;\r\n  }\r\n \r\n  Dropdown(value: any, index: number, event: MouseEvent) {\r\n    event.stopPropagation();\r\n    this.dataObject.forEach((item: any, i: any) => {\r\n      if (i !== index) {\r\n        item.isOpen = false;\r\n      }\r\n    });\r\n    this.dataObject[index].isOpen = !this.dataObject[index].isOpen; \r\n  }\r\n\r\n  toggleCheckbox(event: any, store: any, index: number, subIndex: number) {\r\n    const selectedStores = this.dataObject[index].Stores;\r\n    this.selectedValuesArray[index] = this.selectedValuesArray[index] || [];\r\n  \r\n    if (store === 'Select All') {\r\n      const checked = event.target.checked;\r\n      selectedStores.forEach((item: any) => item.checked = checked);\r\n      this.selectedValuesArray[index] = checked ? [...selectedStores] : [];\r\n    } else {\r\n      const isChecked = event.target.checked;\r\n      const storeIndex = this.selectedValuesArray[index].findIndex((item: any) => item.storeName === store.storeName);\r\n      isChecked ? this.selectedValuesArray[index].push(store) : this.selectedValuesArray[index].splice(storeIndex, 1);\r\n      this.dataObject[index].Stores[subIndex].checked = isChecked;\r\n    }\r\n  \r\n    const selectAllElement = document.getElementById(`selectall${index}`) as HTMLInputElement;\r\n    if (selectAllElement) selectAllElement.checked = selectedStores.every((item: any) => item.checked);\r\n  \r\n    this.selectedValuesArray[index].forEach((store: any) => {\r\n      const checkboxElement = document.getElementById(`option${store.storeName}`) as HTMLInputElement;\r\n      if (checkboxElement) checkboxElement.checked = store.checked;\r\n    });\r\n  \r\n    this.selectedText = `${this.selectedValuesArray[0].length} Stores Selected`;\r\n    this.groupForm.get('storeList')?.setValue(this.selectedValuesArray[0].map((x:any) => x.storeId));\r\n  }  \r\n\r\n  loadSelectedStores(stores: any[]) {\r\n    this.selectedValuesArray[0] = [];\r\n    this.dataObject[0].Stores.forEach((store: any) => {\r\n      if(stores.includes(store.storeId)) {\r\n        store.checked = true;\r\n        this.selectedValuesArray[0].push(store);\r\n      }\r\n    });\r\n    this.selectedText = `${this.selectedValuesArray[0].length} Stores Selected`;\r\n  }\r\n}","<div class=\"card py-0\">\r\n    <div class=\"card-body py-0 d-flex flex-start flex-column p-9 \">\r\n        <div class=\"my-5\">\r\n            <div class=\"symbol symbol-75px symbol-circle\">\r\n                <svg width=\"56\" height=\"56\" viewBox=\"0 0 56 56\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                    <rect x=\"4\" y=\"4\" width=\"48\" height=\"48\" rx=\"24\" fill=\"#DAF1FF\" />\r\n                    <rect x=\"4\" y=\"4\" width=\"48\" height=\"48\" rx=\"24\" stroke=\"#EAF8FF\" stroke-width=\"8\" />\r\n                    <path\r\n                        d=\"M20.5 23.6816C18.8425 23.6816 17.5 22.2133 17.5 20.4004C17.5 18.5875 18.8425 17.1191 20.5 17.1191C22.1575 17.1191 23.5 18.5875 23.5 20.4004C23.5 22.2133 22.1575 23.6816 20.5 23.6816ZM35.6483 23.6816C33.9908 23.6816 32.6483 22.2133 32.6483 20.4004C32.6483 18.5875 33.9908 17.1191 35.6483 17.1191C37.3058 17.1191 38.6483 18.5875 38.6483 20.4004C38.6483 22.2133 37.3058 23.6816 35.6483 23.6816ZM31.509 26.3066C31.509 28.4805 29.8965 30.2441 27.909 30.2441C25.9215 30.2441 24.309 28.4805 24.309 26.3066C24.309 24.1328 25.9215 22.3691 27.909 22.3691C29.8965 22.3691 31.509 24.1328 31.509 26.3066Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M20.0013 25.7559C17.7925 25.7559 16 27.7164 16 30.1322C16 30.6121 16.36 31.0059 16.7988 31.0059H24.8013H24.8275C23.8338 30.042 23.2038 28.6352 23.2038 27.0684C23.2038 26.7566 23.2263 26.449 23.275 26.1537C22.765 25.8994 22.1988 25.7559 21.6025 25.7559H20.0013Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M31.1725 31.0059H31.1987H39.2012C39.64 31.0059 40 30.6162 40 30.1322C40 27.7164 38.2075 25.7559 35.9987 25.7559H34.3975C33.8012 25.7559 33.235 25.8953 32.725 26.1537C32.77 26.4531 32.7963 26.7566 32.7963 27.0684C32.7963 28.6352 32.17 30.042 31.1725 31.0059Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M25.7988 32.3183C23.0388 32.3183 20.8 34.767 20.8 37.7857C20.8 38.3928 21.25 38.8809 21.8013 38.8809H34.1987C34.7537 38.8809 35.2 38.3887 35.2 37.7857C35.2 34.767 32.9613 32.3183 30.2013 32.3183H25.7988Z\"\r\n                        fill=\"#00A3FF\" />\r\n                </svg>\r\n\r\n            </div>\r\n        </div>\r\n        <div class=\"row w-100\">\r\n            <div *ngIf=\"groupType==='add'\" class=\"col-md-12\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">Add\r\n                    Group</a>\r\n                <div class=\"sub-title\">Please add your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='edit'\" class=\"col-md-12\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">Edit Group</a>\r\n                <div class=\"sub-title\">Edit your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='view'\" class=\"col-md-9\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">View Group</a>\r\n                <div class=\"sub-title\">View your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='view'\" class=\"col-md-3 text-end px-0\" (click)=\"editgroup()\">\r\n                <button class=\"btn btn-outline\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\"\r\n                        viewBox=\"0 0 20 20\" fill=\"none\">\r\n                        <g clip-path=\"url(#clip0_3833_85908)\">\r\n                            <path\r\n                                d=\"M9.16602 3.3332H3.33268C2.89065 3.3332 2.46673 3.50879 2.15417 3.82135C1.84161 4.13391 1.66602 4.55784 1.66602 4.99986V16.6665C1.66602 17.1086 1.84161 17.5325 2.15417 17.845C2.46673 18.1576 2.89065 18.3332 3.33268 18.3332H14.9993C15.4414 18.3332 15.8653 18.1576 16.1779 17.845C16.4904 17.5325 16.666 17.1086 16.666 16.6665V10.8332M15.416 2.0832C15.7475 1.75168 16.1972 1.56543 16.666 1.56543C17.1349 1.56543 17.5845 1.75168 17.916 2.0832C18.2475 2.41472 18.4338 2.86436 18.4338 3.3332C18.4338 3.80204 18.2475 4.25168 17.916 4.5832L9.99935 12.4999L6.66602 13.3332L7.49935 9.99986L15.416 2.0832Z\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </g>\r\n                        <defs>\r\n                            <clipPath id=\"clip0_3833_85908\">\r\n                                <rect width=\"20\" height=\"20\" fill=\"white\" />\r\n                            </clipPath>\r\n                        </defs>\r\n                    </svg></button>\r\n            </div>\r\n        </div>\r\n        <form [formGroup]=\"groupForm\">\r\n            <div class=\"row mt-8\">\r\n                <div class=\"col-md-12 col-lg-12 mb-5\">\r\n                    <label for=\"groupName\" class=\"form-label\">Group Name</label>\r\n                    <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"groupName\"\r\n                        formControlName=\"groupName\">\r\n                </div>\r\n                <div class=\"my-5 dropdown1 cursor-pointer h-700\" *ngFor=\"let item of dataObject; let i = index\">\r\n                    <label for=\"storeList\" class=\"form-label\">Select Stores</label>\r\n                    <input type=\"text\" class=\"form-control disable\" id=\"storeName\" [ngModel]=\"selectedText\"  [ngModelOptions]=\"{standalone: true}\"\r\n                        placeholder=\"Select Stores\" (click)=\"Dropdown('Stores',i,$event)\" readonly>\r\n                    <div *ngIf=\"item.isOpen\" class=\"dropdown-content position-absolute\">\r\n                        <div class=\"form-check d-flex align-items-center pt-3 px-5\">\r\n                            <input class=\"form-check-input\" type=\"checkbox\" value=\"Select All\" id=\"selectall{{i}}\"\r\n                                [checked]=\"selectedValuesArray[i]?.length === item.Stores.length\"\r\n                                (change)=\"toggleCheckbox($event,'Select All', i,0)\">\r\n                            <label class=\"form-check-label px-3\" for=\"selectall{{i}}\">\r\n                                Select All\r\n                            </label>\r\n                        </div>\r\n                        <div class=\"border border-gray mt-3\"></div>\r\n                        <div *ngFor=\"let store of item.Stores;let j=index;\"\r\n                            class=\"form-check d-flex align-items-center py-3 px-5\">\r\n                            <input class=\"form-check-input cursor-pointer\" type=\"checkbox\" [value]=\"store?.storeName\"\r\n                                id=\"option{{store?.storeName}}\" [checked]=\"store?.checked\"\r\n                                (change)=\"toggleCheckbox($event,store,i,j)\">\r\n                            <label class=\"form-check-label px-3 cursor-pointer\" for=\"option{{store?.storeName}}\">\r\n                                {{ store?.storeName }}\r\n                            </label>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n                <div class=\"col-md-12 col-lg-12 mb-5\">\r\n                    <label for=\"description\" class=\"form-label\">Description</label>\r\n                    <textarea rows=\"5\" class=\"form-control\" id=\"description\" formControlName=\"description\"></textarea>\r\n                </div>\r\n            </div>\r\n            <div *ngIf=\"groupType !== 'view'\" role=\"group\" class=\"d-flex mt-3 mb-15\">\r\n                <button type=\"button\" class=\"btn btn-outline w-100 me-3\" (click)=\"cancel()\">Cancel</button>\r\n                <button type=\"submit\" id=\"alert-toast\" class=\"btn btn-primary w-100 ms-3\"\r\n                    (click)=\"groupSubmit()\">Submit</button>\r\n            </div>\r\n        </form>\r\n    </div>\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-group.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/create-group/create-group.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/create-group/create-group.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, HostListener, Input, OnInit } from \"@angular/core\";\r\nimport { FormBuilder, FormGroup, Validators } from \"@angular/forms\";\r\nimport { NgbActiveModal } from \"@ng-bootstrap/ng-bootstrap\";\r\nimport { GroupService } from \"../../services/group.service\";\r\nimport { GlobalStateService, ToastService } from \"tango-app-ui-shared\";\r\n\r\n@Component({\r\n  selector: \"lib-create-group\",\r\n  templateUrl: \"./create-group.component.html\",\r\n  styleUrl: \"./create-group.component.scss\",\r\n})\r\nexport class CreateGroupComponent implements OnInit {\r\n  @Input() type: string;\r\n  @Input() editGroup: any;\r\n\r\n  groupType: string;\r\n  groupForm: FormGroup;\r\n  availableStores: any[];\r\n  selectedValuesArray: any[] = [];\r\n  group: any;\r\n  Opendropdown: boolean;\r\n  dataObject: any[] = [\r\n    { Description: 'Stores', Stores: []},  \r\n  ];\r\n  $headerFilters: any;\r\n  selectedText: string;\r\n\r\n  constructor(\r\n    private activeModal: NgbActiveModal,\r\n    private cd: ChangeDetectorRef,\r\n    private fb: FormBuilder,\r\n    private groupService: GroupService,\r\n    private ts: ToastService,\r\n    private gs: GlobalStateService\r\n  ) {\r\n    this.createForm();\r\n    this.gs.selectedClient.subscribe({\r\n      next: (data: any) => {},\r\n    });\r\n    this.gs.dataRangeValue.subscribe({\r\n      next: (data: any) => {\r\n        this.$headerFilters = data;\r\n        this.getAvailableStores();\r\n      },\r\n    });\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.groupType = this.type;\r\n  }\r\n\r\n  getGroup() {\r\n    this.groupService\r\n      .getGroup({\r\n        clientId: this.editGroup?.clientId,\r\n        groupName: this.editGroup?.groupName,\r\n      })\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          if (res && res.code == 200) {\r\n            this.group = res.data.result;\r\n            this.loadGroup();\r\n          } else {\r\n          }\r\n        },\r\n        error: () => {},\r\n        complete: () => {},\r\n      });\r\n  }\r\n\r\n  loadGroup() {\r\n    this.groupForm = this.fb.group({\r\n      groupName: [this.group?.groupName, Validators.required],\r\n      description: [this.group?.description],\r\n      storeList: [this.group?.storeList, Validators.required],\r\n    });\r\n    this.loadSelectedStores(this.group?.storeList);\r\n  }\r\n\r\n  createForm() {\r\n    this.groupForm = this.fb.group({\r\n      groupName: [\"\", Validators.required],\r\n      description: [\"\"],\r\n      storeList: [[], Validators.required],\r\n    });\r\n  }\r\n\r\n  getAvailableStores() {\r\n    this.groupService.getStores({ clientId: this.$headerFilters.client }).subscribe({\r\n      next: (res: any) => {\r\n        if (res && res.code == 200) {\r\n          this.availableStores = res.data.result;\r\n          this.dataObject[0].Stores = res.data.result;\r\n          this.cd.detectChanges();\r\n          if (this.editGroup) {\r\n            this.getGroup();\r\n          } else {\r\n          }\r\n        } else {\r\n        }\r\n      },\r\n      error: () => { \r\n        this.availableStores = [];\r\n      },\r\n      complete: () => {},\r\n    });\r\n  }\r\n\r\n  cancel() {\r\n    this.activeModal.close();\r\n  }\r\n  editgroup() {\r\n    this.groupType = \"edit\";\r\n  }\r\n\r\n  groupSubmit() {\r\n    if (this.groupType === \"add\") {\r\n      if (this.groupForm.valid) {\r\n        this.groupService\r\n          .createGroup({ ...this.groupForm.value, ...{ clientId: this.$headerFilters.client } })\r\n          .subscribe({\r\n            next: (res: any) => {\r\n              if (res && res.code == 200) {\r\n                this.ts.getSuccessToast(\"Group added successfully\");\r\n                this.activeModal.close();\r\n              } else {\r\n                this.activeModal.close();\r\n                this.ts.getErrorToast('Unable to add Group');\r\n              }\r\n            },\r\n            error: () => {\r\n              this.activeModal.close();\r\n              this.ts.getErrorToast('Unable to add Group');\r\n            },\r\n            complete: () => {},\r\n          });\r\n      }\r\n    } else {\r\n      if (this.groupForm.valid) {\r\n        this.groupService.updateGroup({ ...this.groupForm.value, ...{ clientId: this.$headerFilters.client } }).subscribe({\r\n          next: (res: any) => {\r\n            if (res && res.code == 200) {\r\n              this.ts.getSuccessToast(\"Group updated successfully\");\r\n              this.activeModal.close();\r\n            } else {\r\n              this.activeModal.close();\r\n              this.ts.getErrorToast('Unable to update Group');\r\n            }\r\n          },\r\n          error: () => {\r\n            this.activeModal.close();\r\n            this.ts.getErrorToast('Unable to update Group');\r\n          },\r\n          complete: () => {},\r\n        });\r\n      }\r\n    }\r\n  }\r\n  \r\n  @HostListener('document:click', ['$event'])\r\n  onClick(event: MouseEvent) {\r\n    const\r\n      target = event.target as HTMLElement;\r\n    if (!target.closest('.dropdown1')) {\r\n      this.Opendropdown = false;\r\n    }\r\n    if (!target.closest('.dropdown-content')) {\r\n      this.dataObject.forEach((item: any, i: any) => {\r\n        item.isOpen = false;\r\n      }\r\n      );\r\n    }\r\n  }\r\n \r\n  opendropdown(e: MouseEvent) {\r\n    e.stopPropagation();\r\n    this.Opendropdown = !this.Opendropdown;\r\n  }\r\n \r\n  Dropdown(value: any, index: number, event: MouseEvent) {\r\n    event.stopPropagation();\r\n    this.dataObject.forEach((item: any, i: any) => {\r\n      if (i !== index) {\r\n        item.isOpen = false;\r\n      }\r\n    });\r\n    this.dataObject[index].isOpen = !this.dataObject[index].isOpen; \r\n  }\r\n\r\n  toggleCheckbox(event: any, store: any, index: number, subIndex: number) {\r\n    const selectedStores = this.dataObject[index].Stores;\r\n    this.selectedValuesArray[index] = this.selectedValuesArray[index] || [];\r\n  \r\n    if (store === 'Select All') {\r\n      const checked = event.target.checked;\r\n      selectedStores.forEach((item: any) => item.checked = checked);\r\n      this.selectedValuesArray[index] = checked ? [...selectedStores] : [];\r\n    } else {\r\n      const isChecked = event.target.checked;\r\n      const storeIndex = this.selectedValuesArray[index].findIndex((item: any) => item.storeName === store.storeName);\r\n      isChecked ? this.selectedValuesArray[index].push(store) : this.selectedValuesArray[index].splice(storeIndex, 1);\r\n      this.dataObject[index].Stores[subIndex].checked = isChecked;\r\n    }\r\n  \r\n    const selectAllElement = document.getElementById(`selectall${index}`) as HTMLInputElement;\r\n    if (selectAllElement) selectAllElement.checked = selectedStores.every((item: any) => item.checked);\r\n  \r\n    this.selectedValuesArray[index].forEach((store: any) => {\r\n      const checkboxElement = document.getElementById(`option${store.storeName}`) as HTMLInputElement;\r\n      if (checkboxElement) checkboxElement.checked = store.checked;\r\n    });\r\n  \r\n    this.selectedText = `${this.selectedValuesArray[0].length} Stores Selected`;\r\n    this.groupForm.get('storeList')?.setValue(this.selectedValuesArray[0].map((x:any) => x.storeId));\r\n  }  \r\n\r\n  loadSelectedStores(stores: any[]) {\r\n    this.selectedValuesArray[0] = [];\r\n    this.dataObject[0].Stores.forEach((store: any) => {\r\n      if(stores.includes(store.storeId)) {\r\n        store.checked = true;\r\n        this.selectedValuesArray[0].push(store);\r\n      }\r\n    });\r\n    this.selectedText = `${this.selectedValuesArray[0].length} Stores Selected`;\r\n  }\r\n}","<div class=\"card py-0\">\r\n    <div class=\"card-body py-0 d-flex flex-start flex-column p-9 \">\r\n        <div class=\"my-5\">\r\n            <div class=\"symbol symbol-75px symbol-circle\">\r\n                <svg width=\"56\" height=\"56\" viewBox=\"0 0 56 56\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                    <rect x=\"4\" y=\"4\" width=\"48\" height=\"48\" rx=\"24\" fill=\"#DAF1FF\" />\r\n                    <rect x=\"4\" y=\"4\" width=\"48\" height=\"48\" rx=\"24\" stroke=\"#EAF8FF\" stroke-width=\"8\" />\r\n                    <path\r\n                        d=\"M20.5 23.6816C18.8425 23.6816 17.5 22.2133 17.5 20.4004C17.5 18.5875 18.8425 17.1191 20.5 17.1191C22.1575 17.1191 23.5 18.5875 23.5 20.4004C23.5 22.2133 22.1575 23.6816 20.5 23.6816ZM35.6483 23.6816C33.9908 23.6816 32.6483 22.2133 32.6483 20.4004C32.6483 18.5875 33.9908 17.1191 35.6483 17.1191C37.3058 17.1191 38.6483 18.5875 38.6483 20.4004C38.6483 22.2133 37.3058 23.6816 35.6483 23.6816ZM31.509 26.3066C31.509 28.4805 29.8965 30.2441 27.909 30.2441C25.9215 30.2441 24.309 28.4805 24.309 26.3066C24.309 24.1328 25.9215 22.3691 27.909 22.3691C29.8965 22.3691 31.509 24.1328 31.509 26.3066Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M20.0013 25.7559C17.7925 25.7559 16 27.7164 16 30.1322C16 30.6121 16.36 31.0059 16.7988 31.0059H24.8013H24.8275C23.8338 30.042 23.2038 28.6352 23.2038 27.0684C23.2038 26.7566 23.2263 26.449 23.275 26.1537C22.765 25.8994 22.1988 25.7559 21.6025 25.7559H20.0013Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M31.1725 31.0059H31.1987H39.2012C39.64 31.0059 40 30.6162 40 30.1322C40 27.7164 38.2075 25.7559 35.9987 25.7559H34.3975C33.8012 25.7559 33.235 25.8953 32.725 26.1537C32.77 26.4531 32.7963 26.7566 32.7963 27.0684C32.7963 28.6352 32.17 30.042 31.1725 31.0059Z\"\r\n                        fill=\"#00A3FF\" />\r\n                    <path\r\n                        d=\"M25.7988 32.3183C23.0388 32.3183 20.8 34.767 20.8 37.7857C20.8 38.3928 21.25 38.8809 21.8013 38.8809H34.1987C34.7537 38.8809 35.2 38.3887 35.2 37.7857C35.2 34.767 32.9613 32.3183 30.2013 32.3183H25.7988Z\"\r\n                        fill=\"#00A3FF\" />\r\n                </svg>\r\n\r\n            </div>\r\n        </div>\r\n        <div class=\"row w-100\">\r\n            <div *ngIf=\"groupType==='add'\" class=\"col-md-12\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">Add\r\n                    Group</a>\r\n                <div class=\"sub-title\">Please add your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='edit'\" class=\"col-md-12\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">Edit Group</a>\r\n                <div class=\"sub-title\">Edit your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='view'\" class=\"col-md-9\">\r\n                <a class=\"fs-4 text-gray-800 text-hover-primary fw-bold mb-0 title cursor-pointer\">View Group</a>\r\n                <div class=\"sub-title\">View your group details</div>\r\n            </div>\r\n            <div *ngIf=\"groupType==='view'\" class=\"col-md-3 text-end px-0\" (click)=\"editgroup()\">\r\n                <button class=\"btn btn-outline\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\"\r\n                        viewBox=\"0 0 20 20\" fill=\"none\">\r\n                        <g clip-path=\"url(#clip0_3833_85908)\">\r\n                            <path\r\n                                d=\"M9.16602 3.3332H3.33268C2.89065 3.3332 2.46673 3.50879 2.15417 3.82135C1.84161 4.13391 1.66602 4.55784 1.66602 4.99986V16.6665C1.66602 17.1086 1.84161 17.5325 2.15417 17.845C2.46673 18.1576 2.89065 18.3332 3.33268 18.3332H14.9993C15.4414 18.3332 15.8653 18.1576 16.1779 17.845C16.4904 17.5325 16.666 17.1086 16.666 16.6665V10.8332M15.416 2.0832C15.7475 1.75168 16.1972 1.56543 16.666 1.56543C17.1349 1.56543 17.5845 1.75168 17.916 2.0832C18.2475 2.41472 18.4338 2.86436 18.4338 3.3332C18.4338 3.80204 18.2475 4.25168 17.916 4.5832L9.99935 12.4999L6.66602 13.3332L7.49935 9.99986L15.416 2.0832Z\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </g>\r\n                        <defs>\r\n                            <clipPath id=\"clip0_3833_85908\">\r\n                                <rect width=\"20\" height=\"20\" fill=\"white\" />\r\n                            </clipPath>\r\n                        </defs>\r\n                    </svg></button>\r\n            </div>\r\n        </div>\r\n        <form [formGroup]=\"groupForm\">\r\n            <div class=\"row mt-8\">\r\n                <div class=\"col-md-12 col-lg-12 mb-5\">\r\n                    <label for=\"groupName\" class=\"form-label\">Group Name</label>\r\n                    <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"groupName\"\r\n                        formControlName=\"groupName\">\r\n                </div>\r\n                <div class=\"my-5 dropdown1 cursor-pointer h-700\" *ngFor=\"let item of dataObject; let i = index\">\r\n                    <label for=\"storeList\" class=\"form-label\">Select Stores</label>\r\n                    <input type=\"text\" class=\"form-control disable\" id=\"storeName\" [ngModel]=\"selectedText\"  [ngModelOptions]=\"{standalone: true}\"\r\n                        placeholder=\"Select Stores\" (click)=\"Dropdown('Stores',i,$event)\" readonly>\r\n                    <div *ngIf=\"item.isOpen\" class=\"dropdown-content position-absolute\">\r\n                        <div class=\"form-check d-flex align-items-center pt-3 px-5\">\r\n                            <input class=\"form-check-input\" type=\"checkbox\" value=\"Select All\" id=\"selectall{{i}}\"\r\n                                [checked]=\"selectedValuesArray[i]?.length === item.Stores.length\"\r\n                                (change)=\"toggleCheckbox($event,'Select All', i,0)\">\r\n                            <label class=\"form-check-label px-3\" for=\"selectall{{i}}\">\r\n                                Select All\r\n                            </label>\r\n                        </div>\r\n                        <div class=\"border border-gray mt-3\"></div>\r\n                        <div *ngFor=\"let store of item.Stores;let j=index;\"\r\n                            class=\"form-check d-flex align-items-center py-3 px-5\">\r\n                            <input class=\"form-check-input cursor-pointer\" type=\"checkbox\" [value]=\"store?.storeName\"\r\n                                id=\"option{{store?.storeName}}\" [checked]=\"store?.checked\"\r\n                                (change)=\"toggleCheckbox($event,store,i,j)\">\r\n                            <label class=\"form-check-label px-3 cursor-pointer\" for=\"option{{store?.storeName}}\">\r\n                                {{ store?.storeName }}\r\n                            </label>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n                <div class=\"col-md-12 col-lg-12 mb-5\">\r\n                    <label for=\"description\" class=\"form-label\">Description</label>\r\n                    <textarea rows=\"5\" class=\"form-control\" id=\"description\" formControlName=\"description\"></textarea>\r\n                </div>\r\n            </div>\r\n            <div *ngIf=\"groupType !== 'view'\" role=\"group\" class=\"d-flex mt-3 mb-15\">\r\n                <button type=\"button\" class=\"btn btn-outline w-100 me-3\" (click)=\"cancel()\">Cancel</button>\r\n                <button type=\"submit\" id=\"alert-toast\" class=\"btn btn-primary w-100 ms-3\"\r\n                    (click)=\"groupSubmit()\">Submit</button>\r\n            </div>\r\n        </form>\r\n    </div>\r\n</div>"]}

package/esm2022/lib/components/group-details/group-details.component.mjs

@@ -168,12 +168,12 @@ export class GroupDetailsComponent {
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: GroupDetailsComponent, deps: [{ token: i1.Router }, { token: i2.StoresService }, { token: i3.GroupService }, { token: i0.ChangeDetectorRef }, { token: i4.GlobalStateService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.8", type: GroupDetailsComponent, selector: "lib-group-details", outputs: { dataEvent: "dataEvent" }, ngImport: i0, template: "<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n        <ng-container>\r\n            <!-- *ngIf=\"!loading && !noData\"> -->\r\n            <div class=\"table-responsive\">\r\n                <table class=\"table bottom-border\">\r\n                    <thead class=\"cursor-pointer\">\r\n                        <tr>\r\n                            <!-- <th>\r\n                                    <form class=\"form\">\r\n                                        <div class=\"form-group\">\r\n                                            <div class=\"checkbox-inline\">\r\n                                                <label class=\"checkbox\">\r\n                                                    <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                </label>\r\n                                            </div>\r\n                                        </div>\r\n                                    </form>\r\n                                </th> -->\r\n                            <th (click)=\"onSort('storeId')\">Store Info\r\n                                <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeId')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th>SPOC Contact <span></span> </th>\r\n                            <th>Downtime <span></span> </th>\r\n                            <th>Status <span></span> </th>\r\n                            <th>Status Detail <span></span> </th>\r\n                            <th>Actions</th>\r\n                        </tr>\r\n                    </thead>\r\n                    <tbody>\r\n                        <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                            <tr>\r\n                                <!-- <td>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </td> -->\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                    <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                        <span class=\"my-1 mx-1\">\r\n                                            <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                            </svg>\r\n                                            0%\r\n                                        </span>\r\n                                    </div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                    <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                        {{store?.storeProfile?.state}}</div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                    <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                </td>\r\n                                <td class=\"fw-semibold\">NA</td>\r\n                                <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                <td>\r\n                                    <div class=\"table-title\">Internet Issue</div>\r\n                                    <div class=\"table-sub\">Pending from Client</div>\r\n                                </td>\r\n                                <td>\r\n                                    <button type=\"button\"\r\n                                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                        <span>Config</span>\r\n                                    </button>\r\n                                    <span class=\"dropdown\">\r\n                                        <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                            aria-expanded=\"false\">\r\n                                            <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <path\r\n                                                    d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                            </svg>\r\n                                        </button>\r\n                                        <ul class=\"dropdown-menu\">\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                        </ul>\r\n                                    </span>\r\n                                </td>\r\n                            </tr>\r\n                        </ng-container>\r\n                    </tbody>\r\n                </table>\r\n            </div>\r\n            <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n        </ng-container>\r\n        <!-- <ng-container *ngIf=\"loading && !noData\">\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=\"noData && !loading\">\r\n            <div class=\"row\">\r\n                <div class=\"col-lg-12 mb-3\">\r\n                    <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                        <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container> -->\r\n    </div>\r\n</div>", styles: [".text-sub{color:var(--Gray-500, #667085)!important;font-family:Inter;font-size:14px!important;font-weight:400!important;line-height:20px}.border-val{color:var(--Gray-700, #344054)!important;font-family:Inter;font-size:14px!important;font-weight:600!important;line-height:20px;text-transform:capitalize}.table-title-primary{color:var(--Primary-700, #009BF3)!important;font-weight:500!important}.table-sub{line-height:30px!important;color:var(--Gray-500, #667085)!important}.form-control{color:var(--Gray-500, #667085)!important;font-size:14.56px!important;font-weight:400!important;line-height:21.84px!important;border-radius:7.28px!important;border:.91px solid var(--Gray-300, #D0D5DD)!important;background:var(--White, #FFF)!important;box-shadow:0 .91px 1.82px #1018280d!important}.illustcontent{color:var(--Gray-900, #101828);font-size:16px;font-weight:600}.nav-item .nav-link{color:var(--Gray-500, #667085);font-size:16px;font-weight:500}.profile{color:var(--Primary-600, #00A3FF);padding:6px;font-size:14px;font-weight:500;line-height:20px;border-radius:200px;background:var(--Primary-50, #EAF8FF);width:32px;height:32px}.backArrow{width:44px;height:44px;border-radius:8px;border:1px solid var(--Gray-300, #D0D5DD);background:var(--White, #FFF);box-shadow:0 1px 2px #1018280d}\n"], dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PaginationComponent, selector: "lib-pagination", inputs: ["collection", "itemsPerPage", "currentPage", "totalItems", "directionLinks", "pageSize", "paginationSizes"], outputs: ["pageChange", "pageSizeChange"] }] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.0.8", type: GroupDetailsComponent, selector: "lib-group-details", outputs: { dataEvent: "dataEvent" }, ngImport: i0, template: "<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n            @if(!loading && !noData) {\r\n                <div class=\"table-responsive\">\r\n                    <table class=\"table bottom-border\">\r\n                        <thead class=\"cursor-pointer\">\r\n                            <tr>\r\n                                <!-- <th>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </th> -->\r\n                                <th (click)=\"onSort('storeId')\">Store Info\r\n                                    <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeId')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th>SPOC Contact <span></span> </th>\r\n                                <th>Downtime <span></span> </th>\r\n                                <th>Status <span></span> </th>\r\n                                <th>Status Detail <span></span> </th>\r\n                                <th>Actions</th>\r\n                            </tr>\r\n                        </thead>\r\n                        <tbody>\r\n                            <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                                <tr>\r\n                                    <!-- <td>\r\n                                            <form class=\"form\">\r\n                                                <div class=\"form-group\">\r\n                                                    <div class=\"checkbox-inline\">\r\n                                                        <label class=\"checkbox\">\r\n                                                            <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                        </label>\r\n                                                    </div>\r\n                                                </div>\r\n                                            </form>\r\n                                        </td> -->\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                        <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                            <span class=\"my-1 mx-1\">\r\n                                                <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                                </svg>\r\n                                                0%\r\n                                            </span>\r\n                                        </div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                        <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                            {{store?.storeProfile?.state}}</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                        <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                    </td>\r\n                                    <td class=\"fw-semibold\">NA</td>\r\n                                    <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">Internet Issue</div>\r\n                                        <div class=\"table-sub\">Pending from Client</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <button type=\"button\"\r\n                                            class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                            <span>Config</span>\r\n                                        </button>\r\n                                        <span class=\"dropdown\">\r\n                                            <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                                aria-expanded=\"false\">\r\n                                                <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <path\r\n                                                        d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                </svg>\r\n                                            </button>\r\n                                            <ul class=\"dropdown-menu\">\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                            </ul>\r\n                                        </span>\r\n                                    </td>\r\n                                </tr>\r\n                            </ng-container>\r\n                        </tbody>\r\n                    </table>\r\n                </div>\r\n                <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                    [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                    (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n            } @else if(loading && !noData) {\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                </div>\r\n            } @else if(noData && !loading) {\r\n                <div class=\"row\">\r\n                    <div class=\"col-lg-12 mb-3\">\r\n                        <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                            <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            }\r\n    </div>\r\n</div>", styles: [".text-sub{color:var(--Gray-500, #667085)!important;font-family:Inter;font-size:14px!important;font-weight:400!important;line-height:20px}.border-val{color:var(--Gray-700, #344054)!important;font-family:Inter;font-size:14px!important;font-weight:600!important;line-height:20px;text-transform:capitalize}.table-title-primary{color:var(--Primary-700, #009BF3)!important;font-weight:500!important}.table-sub{line-height:30px!important;color:var(--Gray-500, #667085)!important}.form-control{color:var(--Gray-500, #667085)!important;font-size:14.56px!important;font-weight:400!important;line-height:21.84px!important;border-radius:7.28px!important;border:.91px solid var(--Gray-300, #D0D5DD)!important;background:var(--White, #FFF)!important;box-shadow:0 .91px 1.82px #1018280d!important}.illustcontent{color:var(--Gray-900, #101828);font-size:16px;font-weight:600}.nav-item .nav-link{color:var(--Gray-500, #667085);font-size:16px;font-weight:500}.profile{color:var(--Primary-600, #00A3FF);padding:6px;font-size:14px;font-weight:500;line-height:20px;border-radius:200px;background:var(--Primary-50, #EAF8FF);width:32px;height:32px}.backArrow{width:44px;height:44px;border-radius:8px;border:1px solid var(--Gray-300, #D0D5DD);background:var(--White, #FFF);box-shadow:0 1px 2px #1018280d}.img-src{width:25%;height:20%}\n"], dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PaginationComponent, selector: "lib-pagination", inputs: ["collection", "itemsPerPage", "currentPage", "totalItems", "directionLinks", "pageSize", "paginationSizes"], outputs: ["pageChange", "pageSizeChange"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: GroupDetailsComponent, decorators: [{
             type: Component,
-            args: [{ selector: "lib-group-details", template: "<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n        <ng-container>\r\n            <!-- *ngIf=\"!loading && !noData\"> -->\r\n            <div class=\"table-responsive\">\r\n                <table class=\"table bottom-border\">\r\n                    <thead class=\"cursor-pointer\">\r\n                        <tr>\r\n                            <!-- <th>\r\n                                    <form class=\"form\">\r\n                                        <div class=\"form-group\">\r\n                                            <div class=\"checkbox-inline\">\r\n                                                <label class=\"checkbox\">\r\n                                                    <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                </label>\r\n                                            </div>\r\n                                        </div>\r\n                                    </form>\r\n                                </th> -->\r\n                            <th (click)=\"onSort('storeId')\">Store Info\r\n                                <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeId')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th>SPOC Contact <span></span> </th>\r\n                            <th>Downtime <span></span> </th>\r\n                            <th>Status <span></span> </th>\r\n                            <th>Status Detail <span></span> </th>\r\n                            <th>Actions</th>\r\n                        </tr>\r\n                    </thead>\r\n                    <tbody>\r\n                        <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                            <tr>\r\n                                <!-- <td>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </td> -->\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                    <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                        <span class=\"my-1 mx-1\">\r\n                                            <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                            </svg>\r\n                                            0%\r\n                                        </span>\r\n                                    </div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                    <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                        {{store?.storeProfile?.state}}</div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                    <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                </td>\r\n                                <td class=\"fw-semibold\">NA</td>\r\n                                <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                <td>\r\n                                    <div class=\"table-title\">Internet Issue</div>\r\n                                    <div class=\"table-sub\">Pending from Client</div>\r\n                                </td>\r\n                                <td>\r\n                                    <button type=\"button\"\r\n                                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                        <span>Config</span>\r\n                                    </button>\r\n                                    <span class=\"dropdown\">\r\n                                        <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                            aria-expanded=\"false\">\r\n                                            <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <path\r\n                                                    d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                            </svg>\r\n                                        </button>\r\n                                        <ul class=\"dropdown-menu\">\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                        </ul>\r\n                                    </span>\r\n                                </td>\r\n                            </tr>\r\n                        </ng-container>\r\n                    </tbody>\r\n                </table>\r\n            </div>\r\n            <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n        </ng-container>\r\n        <!-- <ng-container *ngIf=\"loading && !noData\">\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=\"noData && !loading\">\r\n            <div class=\"row\">\r\n                <div class=\"col-lg-12 mb-3\">\r\n                    <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                        <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container> -->\r\n    </div>\r\n</div>", styles: [".text-sub{color:var(--Gray-500, #667085)!important;font-family:Inter;font-size:14px!important;font-weight:400!important;line-height:20px}.border-val{color:var(--Gray-700, #344054)!important;font-family:Inter;font-size:14px!important;font-weight:600!important;line-height:20px;text-transform:capitalize}.table-title-primary{color:var(--Primary-700, #009BF3)!important;font-weight:500!important}.table-sub{line-height:30px!important;color:var(--Gray-500, #667085)!important}.form-control{color:var(--Gray-500, #667085)!important;font-size:14.56px!important;font-weight:400!important;line-height:21.84px!important;border-radius:7.28px!important;border:.91px solid var(--Gray-300, #D0D5DD)!important;background:var(--White, #FFF)!important;box-shadow:0 .91px 1.82px #1018280d!important}.illustcontent{color:var(--Gray-900, #101828);font-size:16px;font-weight:600}.nav-item .nav-link{color:var(--Gray-500, #667085);font-size:16px;font-weight:500}.profile{color:var(--Primary-600, #00A3FF);padding:6px;font-size:14px;font-weight:500;line-height:20px;border-radius:200px;background:var(--Primary-50, #EAF8FF);width:32px;height:32px}.backArrow{width:44px;height:44px;border-radius:8px;border:1px solid var(--Gray-300, #D0D5DD);background:var(--White, #FFF);box-shadow:0 1px 2px #1018280d}\n"] }]
+            args: [{ selector: "lib-group-details", template: "<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n            @if(!loading && !noData) {\r\n                <div class=\"table-responsive\">\r\n                    <table class=\"table bottom-border\">\r\n                        <thead class=\"cursor-pointer\">\r\n                            <tr>\r\n                                <!-- <th>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </th> -->\r\n                                <th (click)=\"onSort('storeId')\">Store Info\r\n                                    <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeId')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th>SPOC Contact <span></span> </th>\r\n                                <th>Downtime <span></span> </th>\r\n                                <th>Status <span></span> </th>\r\n                                <th>Status Detail <span></span> </th>\r\n                                <th>Actions</th>\r\n                            </tr>\r\n                        </thead>\r\n                        <tbody>\r\n                            <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                                <tr>\r\n                                    <!-- <td>\r\n                                            <form class=\"form\">\r\n                                                <div class=\"form-group\">\r\n                                                    <div class=\"checkbox-inline\">\r\n                                                        <label class=\"checkbox\">\r\n                                                            <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                        </label>\r\n                                                    </div>\r\n                                                </div>\r\n                                            </form>\r\n                                        </td> -->\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                        <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                            <span class=\"my-1 mx-1\">\r\n                                                <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                                </svg>\r\n                                                0%\r\n                                            </span>\r\n                                        </div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                        <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                            {{store?.storeProfile?.state}}</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                        <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                    </td>\r\n                                    <td class=\"fw-semibold\">NA</td>\r\n                                    <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">Internet Issue</div>\r\n                                        <div class=\"table-sub\">Pending from Client</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <button type=\"button\"\r\n                                            class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                            <span>Config</span>\r\n                                        </button>\r\n                                        <span class=\"dropdown\">\r\n                                            <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                                aria-expanded=\"false\">\r\n                                                <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <path\r\n                                                        d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                </svg>\r\n                                            </button>\r\n                                            <ul class=\"dropdown-menu\">\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                            </ul>\r\n                                        </span>\r\n                                    </td>\r\n                                </tr>\r\n                            </ng-container>\r\n                        </tbody>\r\n                    </table>\r\n                </div>\r\n                <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                    [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                    (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n            } @else if(loading && !noData) {\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                </div>\r\n            } @else if(noData && !loading) {\r\n                <div class=\"row\">\r\n                    <div class=\"col-lg-12 mb-3\">\r\n                        <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                            <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            }\r\n    </div>\r\n</div>", styles: [".text-sub{color:var(--Gray-500, #667085)!important;font-family:Inter;font-size:14px!important;font-weight:400!important;line-height:20px}.border-val{color:var(--Gray-700, #344054)!important;font-family:Inter;font-size:14px!important;font-weight:600!important;line-height:20px;text-transform:capitalize}.table-title-primary{color:var(--Primary-700, #009BF3)!important;font-weight:500!important}.table-sub{line-height:30px!important;color:var(--Gray-500, #667085)!important}.form-control{color:var(--Gray-500, #667085)!important;font-size:14.56px!important;font-weight:400!important;line-height:21.84px!important;border-radius:7.28px!important;border:.91px solid var(--Gray-300, #D0D5DD)!important;background:var(--White, #FFF)!important;box-shadow:0 .91px 1.82px #1018280d!important}.illustcontent{color:var(--Gray-900, #101828);font-size:16px;font-weight:600}.nav-item .nav-link{color:var(--Gray-500, #667085);font-size:16px;font-weight:500}.profile{color:var(--Primary-600, #00A3FF);padding:6px;font-size:14px;font-weight:500;line-height:20px;border-radius:200px;background:var(--Primary-50, #EAF8FF);width:32px;height:32px}.backArrow{width:44px;height:44px;border-radius:8px;border:1px solid var(--Gray-300, #D0D5DD);background:var(--White, #FFF);box-shadow:0 1px 2px #1018280d}.img-src{width:25%;height:20%}\n"] }]
         }], ctorParameters: () => [{ type: i1.Router }, { type: i2.StoresService }, { type: i3.GroupService }, { type: i0.ChangeDetectorRef }, { type: i4.GlobalStateService }], propDecorators: { dataEvent: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group-details.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/group-details/group-details.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/group-details/group-details.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  OnInit,\r\n  Output,\r\n} from \"@angular/core\";\r\nimport { Router } from \"@angular/router\";\r\nimport { StoresService } from \"../../services/stores.service\";\r\nimport { GlobalStateService } from \"tango-app-ui-shared\";\r\nimport { GroupService } from \"../../services/group.service\";\r\n\r\n@Component({\r\n  selector: \"lib-group-details\",\r\n  templateUrl: \"./group-details.component.html\",\r\n  styleUrl: \"./group-details.component.scss\",\r\n})\r\nexport class GroupDetailsComponent implements OnInit {\r\n  @Output() dataEvent = new EventEmitter<string>();\r\n\r\n  searchValue: any;\r\n  storeList: any[] = [];\r\n  storeList_req: any;\r\n  pagination: any;\r\n  loading: boolean;\r\n  noData: boolean;\r\n  supportEmail: string;\r\n  columns: any[] = [\r\n    {\r\n      column: \"storeId\",\r\n      direction: 1,\r\n    },\r\n    {\r\n      column: \"storeProfile.address\",\r\n      direction: 0,\r\n    },\r\n  ];\r\n  paginationSizes: number[] = [10, 20, 30];\r\n  $headerFilters: any;\r\n  group: any;\r\n\r\n  constructor(\r\n    private router: Router,\r\n    private storesService: StoresService,\r\n    private groupService: GroupService,\r\n    private changeDetector: ChangeDetectorRef,\r\n    private gs: GlobalStateService,\r\n  ) {\r\n    this.groupService.groupComms.subscribe({\r\n      next:(group:any)=>{\r\n        this.group = group;\r\n      }\r\n    })\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.gs.dataRangeValue.subscribe((data:any) => {\r\n      this.$headerFilters = data;\r\n      this.storeList_req = {\r\n        clientId: this.$headerFilters.client,\r\n        fromDate:  (this.$headerFilters?.date?.startDate),\r\n        toDate: this.$headerFilters?.date?.endDate,\r\n        limit: 10,\r\n        offset: 1,\r\n        sortBy: \"storeId\",\r\n        sortOrder: 1,\r\n        search: \"\",\r\n        groupName: this.group.groupName\r\n      };\r\n      this.pagination = {\r\n        offset: 1,\r\n        limit: 10,\r\n        totalCount: 0,\r\n        totalPages: 0,\r\n      };\r\n      this.loadTable();\r\n    });\r\n  }\r\n\r\n  backToGroup() {\r\n    const dataToGroup = \"groups\";\r\n    this.dataEvent.emit(dataToGroup);\r\n  }\r\n\r\n  searchData() {}\r\n\r\n  loadTable() {\r\n    this.loading = true;\r\n    this.storesService.getStoreList(this.storeList_req).subscribe({\r\n      next: (res: any) => {\r\n        if (res && res.code === 200) {\r\n          this.storeList = res.data.results;\r\n          this.pagination = {\r\n            offset: res.data.offset,\r\n            limit: res.data.limit,\r\n            totalCount: res.data.totalCount,\r\n            totalPages: res.data.totalPages,\r\n          };\r\n          if (res.data.totalCount < 10) {\r\n            this.paginationSizes = [res.data.totalCount];\r\n          } else {\r\n            this.paginationSizes = [10, 20, 30];\r\n          }\r\n          this.noData = false;\r\n          // this.loading = false;\r\n          this.changeDetector.detectChanges();\r\n        } else {\r\n          this.storeList = [];\r\n          this.pagination = {\r\n            offset: 1,\r\n            limit: 10,\r\n            totalCount: 0,\r\n            totalPages: 0,\r\n          };\r\n          // this.loading = false;\r\n          this.noData = true;\r\n        }\r\n      },\r\n      error: () => {\r\n        this.storeList = [];\r\n        this.pagination = {\r\n          offset: 1,\r\n          limit: 10,\r\n          totalCount: 0,\r\n          totalPages: 0,\r\n        };\r\n        this.loading = false;\r\n        this.noData = true;\r\n      },\r\n      complete: () => {\r\n        this.loading = false;\r\n      },\r\n    });\r\n  }\r\n\r\n  onPageChange(pageOffset: number) {\r\n    this.storeList_req.offset = pageOffset;\r\n    this.pagination.offset = pageOffset;\r\n    this.loadTable();\r\n  }\r\n\r\n  onPageSizeChange(pageSize: number) {\r\n    this.storeList_req.limit = pageSize;\r\n    this.pagination.limit = pageSize;\r\n    this.loadTable();\r\n  }\r\n\r\n  onSort(column: string) {\r\n    this.columns.forEach((el: any, i: number) => {\r\n      if (el.column == column) {\r\n        this.storeList_req.sortBy = column;\r\n        if (this.columns[i].direction == 0) {\r\n          this.columns[i].direction = 1;\r\n          this.storeList_req.sortOrder = 1;\r\n        } else if (this.columns[i].direction == 1) {\r\n          this.columns[i].direction = -1;\r\n          this.storeList_req.sortOrder = -1;\r\n        } else if (this.columns[i].direction == -1) {\r\n          this.columns[i].direction = 0;\r\n          this.storeList_req.sortOrder = -1;\r\n          this.storeList_req.sortBy = \"storeId\";\r\n        }\r\n      } else {\r\n        this.columns[i].direction = 0;\r\n      }\r\n    });\r\n    this.loadTable();\r\n  }\r\n\r\n  colDirection(column: string): number {\r\n    return this.columns.filter((el) => el.column == column)[0].direction;\r\n  }\r\n\r\n  paginationSize(): number {\r\n    if (this.pagination.totalCount < 10) {\r\n      return this.pagination.totalCount;\r\n    } else {\r\n      return this.pagination.limit;\r\n    }\r\n  }\r\n}\r\n","<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n        <ng-container>\r\n            <!-- *ngIf=\"!loading && !noData\"> -->\r\n            <div class=\"table-responsive\">\r\n                <table class=\"table bottom-border\">\r\n                    <thead class=\"cursor-pointer\">\r\n                        <tr>\r\n                            <!-- <th>\r\n                                    <form class=\"form\">\r\n                                        <div class=\"form-group\">\r\n                                            <div class=\"checkbox-inline\">\r\n                                                <label class=\"checkbox\">\r\n                                                    <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                </label>\r\n                                            </div>\r\n                                        </div>\r\n                                    </form>\r\n                                </th> -->\r\n                            <th (click)=\"onSort('storeId')\">Store Info\r\n                                <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeId')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                                <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                    <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                        xmlns=\"http://www.w3.org/2000/svg\">\r\n                                        <path\r\n                                            d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                            stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </svg>\r\n                                </span>\r\n                            </th>\r\n                            <th>SPOC Contact <span></span> </th>\r\n                            <th>Downtime <span></span> </th>\r\n                            <th>Status <span></span> </th>\r\n                            <th>Status Detail <span></span> </th>\r\n                            <th>Actions</th>\r\n                        </tr>\r\n                    </thead>\r\n                    <tbody>\r\n                        <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                            <tr>\r\n                                <!-- <td>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </td> -->\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                    <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                        <span class=\"my-1 mx-1\">\r\n                                            <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                            </svg>\r\n                                            0%\r\n                                        </span>\r\n                                    </div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                    <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                        {{store?.storeProfile?.state}}</div>\r\n                                </td>\r\n                                <td>\r\n                                    <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                    <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                </td>\r\n                                <td class=\"fw-semibold\">NA</td>\r\n                                <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                <td>\r\n                                    <div class=\"table-title\">Internet Issue</div>\r\n                                    <div class=\"table-sub\">Pending from Client</div>\r\n                                </td>\r\n                                <td>\r\n                                    <button type=\"button\"\r\n                                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                        <span>Config</span>\r\n                                    </button>\r\n                                    <span class=\"dropdown\">\r\n                                        <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                            aria-expanded=\"false\">\r\n                                            <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                <path\r\n                                                    d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                                <path\r\n                                                    d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                    stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                    stroke-linejoin=\"round\" />\r\n                                            </svg>\r\n                                        </button>\r\n                                        <ul class=\"dropdown-menu\">\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                            <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                        </ul>\r\n                                    </span>\r\n                                </td>\r\n                            </tr>\r\n                        </ng-container>\r\n                    </tbody>\r\n                </table>\r\n            </div>\r\n            <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n        </ng-container>\r\n        <!-- <ng-container *ngIf=\"loading && !noData\">\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=\"noData && !loading\">\r\n            <div class=\"row\">\r\n                <div class=\"col-lg-12 mb-3\">\r\n                    <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                        <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        </ng-container> -->\r\n    </div>\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group-details.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/group-details/group-details.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/group-details/group-details.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  EventEmitter,\r\n  OnInit,\r\n  Output,\r\n} from \"@angular/core\";\r\nimport { Router } from \"@angular/router\";\r\nimport { StoresService } from \"../../services/stores.service\";\r\nimport { GlobalStateService } from \"tango-app-ui-shared\";\r\nimport { GroupService } from \"../../services/group.service\";\r\n\r\n@Component({\r\n  selector: \"lib-group-details\",\r\n  templateUrl: \"./group-details.component.html\",\r\n  styleUrl: \"./group-details.component.scss\",\r\n})\r\nexport class GroupDetailsComponent implements OnInit {\r\n  @Output() dataEvent = new EventEmitter<string>();\r\n\r\n  searchValue: any;\r\n  storeList: any[] = [];\r\n  storeList_req: any;\r\n  pagination: any;\r\n  loading: boolean;\r\n  noData: boolean;\r\n  supportEmail: string;\r\n  columns: any[] = [\r\n    {\r\n      column: \"storeId\",\r\n      direction: 1,\r\n    },\r\n    {\r\n      column: \"storeProfile.address\",\r\n      direction: 0,\r\n    },\r\n  ];\r\n  paginationSizes: number[] = [10, 20, 30];\r\n  $headerFilters: any;\r\n  group: any;\r\n\r\n  constructor(\r\n    private router: Router,\r\n    private storesService: StoresService,\r\n    private groupService: GroupService,\r\n    private changeDetector: ChangeDetectorRef,\r\n    private gs: GlobalStateService,\r\n  ) {\r\n    this.groupService.groupComms.subscribe({\r\n      next:(group:any)=>{\r\n        this.group = group;\r\n      }\r\n    })\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.gs.dataRangeValue.subscribe((data:any) => {\r\n      this.$headerFilters = data;\r\n      this.storeList_req = {\r\n        clientId: this.$headerFilters.client,\r\n        fromDate:  (this.$headerFilters?.date?.startDate),\r\n        toDate: this.$headerFilters?.date?.endDate,\r\n        limit: 10,\r\n        offset: 1,\r\n        sortBy: \"storeId\",\r\n        sortOrder: 1,\r\n        search: \"\",\r\n        groupName: this.group.groupName\r\n      };\r\n      this.pagination = {\r\n        offset: 1,\r\n        limit: 10,\r\n        totalCount: 0,\r\n        totalPages: 0,\r\n      };\r\n      this.loadTable();\r\n    });\r\n  }\r\n\r\n  backToGroup() {\r\n    const dataToGroup = \"groups\";\r\n    this.dataEvent.emit(dataToGroup);\r\n  }\r\n\r\n  searchData() {}\r\n\r\n  loadTable() {\r\n    this.loading = true;\r\n    this.storesService.getStoreList(this.storeList_req).subscribe({\r\n      next: (res: any) => {\r\n        if (res && res.code === 200) {\r\n          this.storeList = res.data.results;\r\n          this.pagination = {\r\n            offset: res.data.offset,\r\n            limit: res.data.limit,\r\n            totalCount: res.data.totalCount,\r\n            totalPages: res.data.totalPages,\r\n          };\r\n          if (res.data.totalCount < 10) {\r\n            this.paginationSizes = [res.data.totalCount];\r\n          } else {\r\n            this.paginationSizes = [10, 20, 30];\r\n          }\r\n          this.noData = false;\r\n          // this.loading = false;\r\n          this.changeDetector.detectChanges();\r\n        } else {\r\n          this.storeList = [];\r\n          this.pagination = {\r\n            offset: 1,\r\n            limit: 10,\r\n            totalCount: 0,\r\n            totalPages: 0,\r\n          };\r\n          // this.loading = false;\r\n          this.noData = true;\r\n        }\r\n      },\r\n      error: () => {\r\n        this.storeList = [];\r\n        this.pagination = {\r\n          offset: 1,\r\n          limit: 10,\r\n          totalCount: 0,\r\n          totalPages: 0,\r\n        };\r\n        this.loading = false;\r\n        this.noData = true;\r\n      },\r\n      complete: () => {\r\n        this.loading = false;\r\n      },\r\n    });\r\n  }\r\n\r\n  onPageChange(pageOffset: number) {\r\n    this.storeList_req.offset = pageOffset;\r\n    this.pagination.offset = pageOffset;\r\n    this.loadTable();\r\n  }\r\n\r\n  onPageSizeChange(pageSize: number) {\r\n    this.storeList_req.limit = pageSize;\r\n    this.pagination.limit = pageSize;\r\n    this.loadTable();\r\n  }\r\n\r\n  onSort(column: string) {\r\n    this.columns.forEach((el: any, i: number) => {\r\n      if (el.column == column) {\r\n        this.storeList_req.sortBy = column;\r\n        if (this.columns[i].direction == 0) {\r\n          this.columns[i].direction = 1;\r\n          this.storeList_req.sortOrder = 1;\r\n        } else if (this.columns[i].direction == 1) {\r\n          this.columns[i].direction = -1;\r\n          this.storeList_req.sortOrder = -1;\r\n        } else if (this.columns[i].direction == -1) {\r\n          this.columns[i].direction = 0;\r\n          this.storeList_req.sortOrder = -1;\r\n          this.storeList_req.sortBy = \"storeId\";\r\n        }\r\n      } else {\r\n        this.columns[i].direction = 0;\r\n      }\r\n    });\r\n    this.loadTable();\r\n  }\r\n\r\n  colDirection(column: string): number {\r\n    return this.columns.filter((el) => el.column == column)[0].direction;\r\n  }\r\n\r\n  paginationSize(): number {\r\n    if (this.pagination.totalCount < 10) {\r\n      return this.pagination.totalCount;\r\n    } else {\r\n      return this.pagination.limit;\r\n    }\r\n  }\r\n}\r\n","<div class=\"card mb-10\">\r\n    <div class=\"card-header border-0 pt-3\">\r\n        <div class=\"d-flex justify-content-left align-items-center\">\r\n            <div class=\"backArrow d-flex justify-content-center align-items-center me-5 ml-0\">\r\n                <button (click)=\"backToGroup()\"\r\n                    class=\"btn btn-default mx-2  btn-outline-default rounded-3 text-nowrap\"><svg\r\n                        xmlns=\"http://www.w3.org/2000/svg\" width=\"21\" height=\"20\" viewBox=\"0 0 21 20\" fill=\"none\">\r\n                        <path d=\"M16.3333 9.99996H4.66663M4.66663 9.99996L10.5 15.8333M4.66663 9.99996L10.5 4.16663\"\r\n                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                    </svg></button>\r\n            </div>\r\n            <h3 class=\"card-title align-items-start flex-column\">\r\n                <span class=\"card-label mb-2\">{{group?.groupName}}</span>\r\n                <span class=\"text-sub mb-2\">{{pagination.totalCount ? pagination.totalCount : '--'}} total stores</span>\r\n            </h3>\r\n        </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                    <span class=\"svg-icon svg-icon-1 position-absolute ms-3\">\r\n                        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\">\r\n                            <rect opacity=\"0.5\" x=\"17.0365\" y=\"15.1223\" width=\"8.15546\" height=\"2\" rx=\"1\"\r\n                                transform=\"rotate(45 17.0365 15.1223)\" fill=\"currentColor\"></rect>\r\n                            <path\r\n                                d=\"M11 19C6.55556 19 3 15.4444 3 11C3 6.55556 6.55556 3 11 3C15.4444 3 19 6.55556 19 11C19 15.4444 15.4444 19 11 19ZM11 5C7.53333 5 5 7.53333 5 11C5 14.4667 7.53333 17 11 17C14.4667 17 17 14.4667 17 11C17 7.53333 14.4667 5 11 5Z\"\r\n                                fill=\"currentColor\"></path>\r\n                        </svg>\r\n                    </span>\r\n                    <input type=\"text\" (change)=\"searchData()\" class=\"form-control ps-14 me-2\" name=\"search\"\r\n                        autocomplete=\"off\" placeholder=\"Search\" autocomplete=\"off\" />\r\n                    <button type=\"button\"\r\n                        class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\"><svg\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\">\r\n                            <path\r\n                                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\"\r\n                                stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                        </svg><span class=\"ms-2\">Export</span> </button>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n    <div class=\"card-body p-0\">\r\n            @if(!loading && !noData) {\r\n                <div class=\"table-responsive\">\r\n                    <table class=\"table bottom-border\">\r\n                        <thead class=\"cursor-pointer\">\r\n                            <tr>\r\n                                <!-- <th>\r\n                                        <form class=\"form\">\r\n                                            <div class=\"form-group\">\r\n                                                <div class=\"checkbox-inline\">\r\n                                                    <label class=\"checkbox\">\r\n                                                        <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                    </label>\r\n                                                </div>\r\n                                            </div>\r\n                                        </form>\r\n                                    </th> -->\r\n                                <th (click)=\"onSort('storeId')\">Store Info\r\n                                    <span *ngIf=\"colDirection('storeId')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeId')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th (click)=\"onSort('storeProfile.address')\">Location\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===-1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 1.33337V10.6667M6.00016 10.6667L10.6668 6.00004M6.00016 10.6667L1.3335 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                    <span *ngIf=\"colDirection('storeProfile.address')===1\">\r\n                                        <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\"\r\n                                            xmlns=\"http://www.w3.org/2000/svg\">\r\n                                            <path\r\n                                                d=\"M6.00016 10.6667L6.00016 1.33337M6.00016 1.33337L1.3335 6.00004M6.00016 1.33337L10.6668 6.00004\"\r\n                                                stroke=\"#667085\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\r\n                                                stroke-linejoin=\"round\" />\r\n                                        </svg>\r\n                                    </span>\r\n                                </th>\r\n                                <th>SPOC Contact <span></span> </th>\r\n                                <th>Downtime <span></span> </th>\r\n                                <th>Status <span></span> </th>\r\n                                <th>Status Detail <span></span> </th>\r\n                                <th>Actions</th>\r\n                            </tr>\r\n                        </thead>\r\n                        <tbody>\r\n                            <ng-container *ngFor=\"let store of storeList;let i=index;\">\r\n                                <tr>\r\n                                    <!-- <td>\r\n                                            <form class=\"form\">\r\n                                                <div class=\"form-group\">\r\n                                                    <div class=\"checkbox-inline\">\r\n                                                        <label class=\"checkbox\">\r\n                                                            <input type=\"checkbox\" checked=\"checked\" name=\"Checkboxes1\">\r\n                                                        </label>\r\n                                                    </div>\r\n                                                </div>\r\n                                            </form>\r\n                                        </td> -->\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeName}}</div>\r\n                                        <div class=\"table-sub\">ID : {{store?.storeId}}\r\n                                            <span class=\"my-1 mx-1\">\r\n                                                <svg width=\"8\" height=\"8\" viewBox=\"0 0 8 8\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <circle cx=\"4\" cy=\"4\" r=\"3\" fill=\"#12B76A\" />\r\n                                                </svg>\r\n                                                0%\r\n                                            </span>\r\n                                        </div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.storeProfile?.address}}, </div>\r\n                                        <div class=\"table-sub\">{{store?.storeProfile?.city}},\r\n                                            {{store?.storeProfile?.state}}</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">{{store?.spocDetails[0]?.email}}</div>\r\n                                        <div class=\"table-sub\">{{store?.spocDetails[0]?.contact}}</div>\r\n                                    </td>\r\n                                    <td class=\"fw-semibold\">NA</td>\r\n                                    <td><span class=\"badge badge-light-primary\">Onboarded</span></td>\r\n                                    <td>\r\n                                        <div class=\"table-title\">Internet Issue</div>\r\n                                        <div class=\"table-sub\">Pending from Client</div>\r\n                                    </td>\r\n                                    <td>\r\n                                        <button type=\"button\"\r\n                                            class=\"btn btn-default mx-2 btn-outline btn-outline-default rounded-3 text-nowrap border-val\">\r\n                                            <span>Config</span>\r\n                                        </button>\r\n                                        <span class=\"dropdown\">\r\n                                            <button style=\"border: none;background-color: white\" data-bs-toggle=\"dropdown\"\r\n                                                aria-expanded=\"false\">\r\n                                                <svg width=\"36\" height=\"36\" viewBox=\"0 0 36 36\" fill=\"none\"\r\n                                                    xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <path\r\n                                                        d=\"M18.0001 18.8334C18.4603 18.8334 18.8334 18.4603 18.8334 18C18.8334 17.5398 18.4603 17.1667 18.0001 17.1667C17.5398 17.1667 17.1667 17.5398 17.1667 18C17.1667 18.4603 17.5398 18.8334 18.0001 18.8334Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 13C18.4603 13 18.8334 12.6269 18.8334 12.1667C18.8334 11.7065 18.4603 11.3334 18.0001 11.3334C17.5398 11.3334 17.1667 11.7065 17.1667 12.1667C17.1667 12.6269 17.5398 13 18.0001 13Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                    <path\r\n                                                        d=\"M18.0001 24.6667C18.4603 24.6667 18.8334 24.2936 18.8334 23.8334C18.8334 23.3731 18.4603 23 18.0001 23C17.5398 23 17.1667 23.3731 17.1667 23.8334C17.1667 24.2936 17.5398 24.6667 18.0001 24.6667Z\"\r\n                                                        stroke=\"#667085\" stroke-width=\"1.66667\" stroke-linecap=\"round\"\r\n                                                        stroke-linejoin=\"round\" />\r\n                                                </svg>\r\n                                            </button>\r\n                                            <ul class=\"dropdown-menu\">\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Edit Store</button></li>\r\n                                                <li><button class=\"dropdown-item\" type=\"button\">Deactivate</button></li>\r\n                                            </ul>\r\n                                        </span>\r\n                                    </td>\r\n                                </tr>\r\n                            </ng-container>\r\n                        </tbody>\r\n                    </table>\r\n                </div>\r\n                <lib-pagination [itemsPerPage]=\"pagination.limit\" [currentPage]=\"pagination.offset\"\r\n                    [totalItems]=\"pagination.totalCount\" [paginationSizes]=\"paginationSizes\" [pageSize]=\"paginationSize()\"\r\n                    (pageChange)=\"onPageChange($event)\" (pageSizeChange)=\"onPageSizeChange($event)\"></lib-pagination>\r\n            } @else if(loading && !noData) {\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                </div>\r\n            } @else if(noData && !loading) {\r\n                <div class=\"row\">\r\n                    <div class=\"col-lg-12 mb-3\">\r\n                        <div class=\"card-body d-flex justify-content-center align-items-center flex-column\">\r\n                            <img class=\"img-src\" src=\"./assets/tango/Icons/Nodata.svg\" alt=\"\">\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n            }\r\n    </div>\r\n</div>"]}