tango-app-ui-manage-stores 3.0.28-dev → 3.0.29-dev

package/esm2022/lib/components/add-stores-form/add-stores-form.component.mjs

@@ -202,28 +202,31 @@ export class AddStoresFormComponent {
                     });
                 }
             }
-            this.storesService.createStore(store).subscribe((res) => {
-                if (res && res.code === 200 && res.status === "success") {
-                    this.ts.getSuccessToast("Store Created Successfully!");
-                    if (res.data.store && res.data.store.storeId) {
-                        this.storesService
-                            .createInfraTicket({
-                            storeId: res.data.store.storeId,
-                            Date: new Date().toISOString().split("T")[0],
-                            issueType: "installation",
-                        })
-                            .subscribe({
-                            next: (res) => { },
-                            error: () => { },
-                        });
+            this.storesService.createStore(store).subscribe({
+                next: (res) => {
+                    if (res && res.code === 200 && res.status === "success") {
+                        this.ts.getSuccessToast("Store Created Successfully!");
+                        if (res.data.store && res.data.store.storeId) {
+                            this.storesService
+                                .createInfraTicket({
+                                storeId: res.data.store.storeId,
+                                Date: new Date().toISOString().split("T")[0],
+                                issueType: "installation",
+                            })
+                                .subscribe({
+                                next: (res) => { },
+                                error: () => { },
+                            });
+                        }
+                        this.router.navigate(["/manage/stores"]);
                     }
-                    this.router.navigate(["/manage/stores"]);
-                }
-                else {
-                    this.ts.getErrorToast("Unable to create store!");
+                    else {
+                        this.ts.getErrorToast("Unable to create store!");
+                    }
+                },
+                error: (error) => {
+                    this.ts.getErrorToast(error?.error?.error ? error?.error?.error : "Unable to create Store!");
                 }
-            }, (error) => {
-                this.ts.getErrorToast("Unable to create store!");
             });
         }
         else {
@@ -250,4 +253,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImpor
                 type: ViewChild,
                 args: ["ngxPlaces"]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-stores-form.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/add-stores-form/add-stores-form.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/add-stores-form/add-stores-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  OnInit,\r\n  ViewChild,\r\n} from \"@angular/core\";\r\nimport { FormBuilder, FormArray, Validators, FormGroup, AbstractControl, ValidationErrors } from \"@angular/forms\";\r\nimport { StoresService } from \"../../services/stores.service\";\r\nimport { HttpErrorResponse } from \"@angular/common/http\";\r\nimport { StoreResponse } from \"../../interfaces/store.interface\";\r\nimport { Router } from \"@angular/router\";\r\nimport * as moment from 'moment-timezone';\r\nimport { NgxGpAutocompleteDirective } from \"@angular-magic/ngx-gp-autocomplete/lib/ngx-gp-autocomplete.directive\";\r\nimport { ToastService } from \"tango-app-ui-shared\";\r\n\r\ndeclare var $: any;\r\n\r\n@Component({\r\n  selector: \"lib-add-stores-form\",\r\n  templateUrl: \"./add-stores-form.component.html\",\r\n  styleUrl: \"./add-stores-form.component.scss\",\r\n})\r\nexport class AddStoresFormComponent implements OnInit {\r\n  @ViewChild(\"ngxPlaces\") placesRef: NgxGpAutocompleteDirective;\r\n\r\n  select = \"store_info\";\r\n  storeForm: FormGroup;\r\n  storeId: string;\r\n  timezones: any[];\r\n  $headerFilters: any;\r\n\r\n  public handleAddressChange(place: google.maps.places.PlaceResult | any) {\r\n    if (place.geometry) {\r\n      let country = \"\", city = \"\", state = \"\", pincode = \"\";\r\n      place.address_components.forEach((component: any) => {\r\n        if (component.types.includes(\"country\")) {\r\n          country = component.long_name;\r\n        } else if (component.types.includes(\"locality\")) {\r\n          city = component.long_name;\r\n        } else if (component.types.includes(\"administrative_area_level_1\")) {\r\n          state = component.long_name;\r\n        } else if (component.types.includes(\"postal_code\")) {\r\n          pincode = component.long_name;\r\n        }\r\n      });\r\n      this.storeForm.get('address')?.setValue(place.formatted_address);\r\n      this.storeForm.get(\"country\")?.setValue(country);\r\n      this.storeForm.get(\"city\")?.setValue(city);\r\n      this.storeForm.get(\"state\")?.setValue(state);\r\n      this.storeForm.get(\"pincode\")?.setValue(pincode);\r\n    }\r\n  }\r\n\r\n  constructor(\r\n    private fb: FormBuilder,\r\n    private storesService: StoresService,\r\n    private ts: ToastService,\r\n    private router: Router\r\n  ) {\r\n    let data:any = JSON.parse(localStorage.getItem('header-filters') || '');\r\n    this.$headerFilters = data;\r\n    this.getAllTimezones();\r\n    this.createForm();\r\n  }\r\n\r\n  ngOnInit() {}\r\n\r\n  settingvalue(label: any) {\r\n    if (label == \"store_info\") {\r\n      this.select = \"store_info\";\r\n    } else if (label == \"config\") {\r\n      this.select = \"config\";\r\n    } else if (label == \"store_loc\") {\r\n      this.select = \"store_loc\";\r\n    } else if (label == \"contact\") {\r\n      this.select = \"contact\";\r\n    } else if (label == \"review\") {\r\n      this.select = \"review\";\r\n    }\r\n  }\r\n\r\n  createForm() {\r\n    this.storeForm = this.fb.group(\r\n      {\r\n        storeName: [\"\", Validators.required],\r\n        clientId: [this.$headerFilters?.client, Validators.required],\r\n        businessType: [\"COCO\", Validators.required],\r\n        storeType_type: [\"High Street\", Validators.required],\r\n        storeType_name: [\"\"],\r\n        storeCode: [\"\"],\r\n        address: [\"\", Validators.required],\r\n        country: [\"\", Validators.required],\r\n        state: [\"\", Validators.required],\r\n        city: [\"\", Validators.required],\r\n        pincode: [\"\", Validators.required],\r\n        timeZone: [\"Asia/Kolkata\", Validators.required],\r\n        open: [\"10:00\", Validators.required],\r\n        close: [\"20:00\", Validators.required],\r\n        // cameras: [0, Validators.required],\r\n        spocDetails: this.fb.array([this.createSpocDetail()]),\r\n        storeConnectionId: [\"\"],\r\n      },\r\n      { validators: this.timeRangeValidator }\r\n    );\r\n  }\r\n\r\n  timeRangeValidator(control: AbstractControl): ValidationErrors | null {\r\n    const openTime = control.get(\"open\")?.value;\r\n    const closeTime = control.get(\"close\")?.value;\r\n    if (openTime && closeTime && openTime >= closeTime) {\r\n      return { invalidTimeRange: true };\r\n    }    \r\n    return null;\r\n  }\r\n\r\n  createSpocDetail(): FormGroup {\r\n    return this.fb.group({\r\n      name: [\"\", Validators.required],\r\n      email: [\r\n        \"\",\r\n        [\r\n          Validators.required,\r\n          Validators.email,\r\n          Validators.maxLength(100),\r\n          Validators.minLength(3),\r\n        ],\r\n      ],\r\n      contact: [\r\n        \"\",\r\n        [\r\n          Validators.required,\r\n          Validators.maxLength(13),\r\n          Validators.minLength(10),\r\n        ],\r\n      ],\r\n      designation: [\"\"],\r\n    });\r\n  }\r\n\r\n  getspocDetailsControls() {\r\n    return (this.storeForm.get(\"spocDetails\") as FormArray).controls;\r\n  }\r\n\r\n  getspocDetailsValues(i: number) {\r\n    return (this.storeForm.get(\"spocDetails\") as FormArray).at(i).value;\r\n  }\r\n\r\n  getStoreProfile(): FormGroup {\r\n    return this.storeForm.get(\"storeProfile\") as FormGroup;\r\n  }\r\n\r\n  goToStoreInfo(): void {\r\n    this.select = \"store_info\";\r\n  }\r\n\r\n  goToConfiguration(): void {\r\n    this.select = \"config\";\r\n  }\r\n\r\n  goToContact(): void {\r\n    this.select = \"contact\";\r\n  }\r\n\r\n  goToReview(): void {\r\n    this.select = \"review\";\r\n  }\r\n\r\n  addSpocDetail() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).push(\r\n      this.createSpocDetail()\r\n    );\r\n  }\r\n\r\n  addAltSpoc() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).push(\r\n      this.createSpocDetail()\r\n    );\r\n  }\r\n\r\n  delAltSpoc() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).removeAt(1);\r\n  }\r\n\r\n  removeSpocDetail(index: number) {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).removeAt(index);\r\n  }\r\n\r\n  onSubmit() {\r\n    if (this.storeForm.valid) {\r\n      let store: StoreResponse = {\r\n        storeName: this.storeForm.value.storeName,\r\n        clientId: this.storeForm.value.clientId,\r\n        businessType: this.storeForm.value.businessType,\r\n        storeType: {\r\n          type: this.storeForm.value.storeType_type,\r\n          name: this.storeForm.value?.storeType_name,\r\n        },\r\n        storeProfile: {\r\n          storeCode: this.storeForm.value?.storeCode,\r\n          address: this.storeForm.value?.address,\r\n          country: this.storeForm.value?.country,\r\n          state: this.storeForm.value?.state,\r\n          city: this.storeForm.value?.city,\r\n          pincode: this.storeForm.value?.pincode,\r\n          timeZone: this.storeForm.value?.timeZone,\r\n          open: this.storeForm.value?.open,\r\n          close: this.storeForm.value?.close,\r\n        },\r\n        // edge: {\r\n        //   camDetails: {\r\n        //     cameras: this.storeForm.value?.cameras,\r\n        //   },\r\n        // },\r\n        spocDetails: [\r\n          {\r\n            name: this.storeForm.value?.spocDetails[0].name,\r\n            email: this.storeForm.value?.spocDetails[0].email,\r\n            contact: this.storeForm.value?.spocDetails[0].contact,\r\n            designation: this.storeForm.value?.spocDetails[0].designation,\r\n          },\r\n        ],\r\n        storeConnectionId: this.storeForm.value?.storeConnectionId,\r\n      };\r\n      if (this.storeForm.value.spocDetails.length > 1) {\r\n        for(let i=1;i<this.storeForm.value.spocDetails.length;i++) {\r\n          store.spocDetails.push({\r\n            name: this.storeForm.value?.spocDetails[i].name,\r\n            email: this.storeForm.value?.spocDetails[i].email,\r\n            contact: this.storeForm.value?.spocDetails[i].contact,\r\n            designation: this.storeForm.value?.spocDetails[i].designation,\r\n          });\r\n        }\r\n      }\r\n\r\n      this.storesService.createStore(store).subscribe(\r\n        (res: any) => {\r\n          if (res && res.code === 200 && res.status === \"success\") {\r\n            this.ts.getSuccessToast(\"Store Created Successfully!\");\r\n            if (res.data.store && res.data.store.storeId) {\r\n              this.storesService\r\n                .createInfraTicket({\r\n                  storeId: res.data.store.storeId,\r\n                  Date: new Date().toISOString().split(\"T\")[0],\r\n                  issueType: \"installation\",\r\n                })\r\n                .subscribe({\r\n                  next: (res: any) => {},\r\n                  error: () => {},\r\n                });\r\n            }\r\n            this.router.navigate([\"/manage/stores\"]);\r\n          } else {\r\n            this.ts.getErrorToast(\"Unable to create store!\");\r\n          }\r\n        },\r\n        (error: HttpErrorResponse) => {\r\n          this.ts.getErrorToast(\"Unable to create store!\");\r\n        }\r\n      );\r\n    } else {\r\n    }\r\n  }\r\n\r\n  navigateToAddStore() {\r\n    this.router.navigate([\"/manage/stores/addition-method\"]);\r\n  }\r\n\r\n  omit_special_char(event: any) {\r\n    var k;\r\n    k = event.charCode; //         k = event.keyCode;  (Both can be used)\r\n    return k == 8 || k == 32 || (k >= 48 && k <= 57);\r\n  }\r\n\r\n  getAllTimezones() {\r\n    this.timezones=moment.tz.names();\r\n  }\r\n}\r\n","<div class=\"row mt-3 mb-6\">\r\n    <div class=\"col-md-3 col-lg-3 col-xl-3 col-xxl-3\" id=\"left-container\">\r\n        <div class=\"card card-flush h-100 mb-0\">\r\n            <!--begin::Aside content-->\r\n            <div class=\"card-body\">\r\n                <div\r\n                    class=\"menu menu-column menu-rounded menu-state-bg menu-state-title-primary menu-state-icon-primary menu-state-bullet-primary\">\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Inbox-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'store_info' }\"\r\n                            (click)=\"settingvalue('store_info')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path stroke=\"currentColor\"\r\n                                        d=\"M3.08995 6.88369L3.02401 6.98669C2.30358 8.25557 3.06101 9.87945 4.46464 10.0662C4.58627 10.0811 4.70112 10.0892 4.8145 10.0892C5.55255 10.0892 6.20523 9.77229 6.65953 9.27917L7.21286 8.67854L7.76432 9.28089C8.21367 9.77171 8.8652 10.0892 9.60776 10.0892C10.3471 10.0892 11.0022 9.77137 11.4512 9.28089L12.0044 8.67665L12.5576 9.28089C13.0066 9.77137 13.6617 10.0892 14.401 10.0892C15.1404 10.0892 15.7954 9.77137 16.2445 9.28089L16.7977 8.67665L17.3508 9.28089C17.7999 9.77137 18.4549 10.0892 19.1943 10.0892C19.3041 10.0892 19.4223 10.0811 19.5433 10.0663C20.9772 9.87168 21.7355 8.16387 20.9155 6.88419C20.9154 6.88413 20.9154 6.88407 20.9154 6.88402L18.8056 3.59429L18.8056 3.59429L18.8046 3.59282C18.7582 3.52002 18.6649 3.46423 18.5584 3.46423H5.44307C5.3365 3.46423 5.24326 3.52002 5.19681 3.59282L5.19619 3.59379L3.08995 6.88369ZM4.81818 12.7499C4.71644 12.7499 4.616 12.7468 4.5169 12.741V16.6428V18.9642C4.5169 19.8211 5.22663 20.5357 6.11942 20.5357H17.882C18.7748 20.5357 19.4845 19.8211 19.4845 18.9642V16.6428V12.7415C19.3874 12.747 19.2893 12.7499 19.1906 12.7499C19.0022 12.7499 18.8157 12.7398 18.632 12.7202V16.6428V17.3928H17.882H6.11942H5.36942V16.6428V12.721C5.18866 12.74 5.00472 12.7499 4.81818 12.7499Z\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Store Info</span>\r\n                        </span>\r\n                        <!--end::Inbox-->\r\n                    </div>\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Inbox-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'config' }\"\r\n                            (click)=\"settingvalue('config')\">\r\n                            <span class=\"menu-icon\">\r\n                                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\"\r\n                                    fill=\"none\">\r\n                                    <g clip-path=\"url(#clip0_1017_22270)\">\r\n                                        <path\r\n                                            d=\"M12 15C13.6569 15 15 13.6569 15 12C15 10.3431 13.6569 9 12 9C10.3431 9 9 10.3431 9 12C9 13.6569 10.3431 15 12 15Z\"\r\n                                            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                        <path\r\n                                            d=\"M19.4 15C19.2669 15.3016 19.2272 15.6362 19.286 15.9606C19.3448 16.285 19.4995 16.5843 19.73 16.82L19.79 16.88C19.976 17.0657 20.1235 17.2863 20.2241 17.5291C20.3248 17.7719 20.3766 18.0322 20.3766 18.295C20.3766 18.5578 20.3248 18.8181 20.2241 19.0609C20.1235 19.3037 19.976 19.5243 19.79 19.71C19.6043 19.896 19.3837 20.0435 19.1409 20.1441C18.8981 20.2448 18.6378 20.2966 18.375 20.2966C18.1122 20.2966 17.8519 20.2448 17.6091 20.1441C17.3663 20.0435 17.1457 19.896 16.96 19.71L16.9 19.65C16.6643 19.4195 16.365 19.2648 16.0406 19.206C15.7162 19.1472 15.3816 19.1869 15.08 19.32C14.7842 19.4468 14.532 19.6572 14.3543 19.9255C14.1766 20.1938 14.0813 20.5082 14.08 20.83V21C14.08 21.5304 13.8693 22.0391 13.4942 22.4142C13.1191 22.7893 12.6104 23 12.08 23C11.5496 23 11.0409 22.7893 10.6658 22.4142C10.2907 22.0391 10.08 21.5304 10.08 21V20.91C10.0723 20.579 9.96512 20.258 9.77251 19.9887C9.5799 19.7194 9.31074 19.5143 9 19.4C8.69838 19.2669 8.36381 19.2272 8.03941 19.286C7.71502 19.3448 7.41568 19.4995 7.18 19.73L7.12 19.79C6.93425 19.976 6.71368 20.1235 6.47088 20.2241C6.22808 20.3248 5.96783 20.3766 5.705 20.3766C5.44217 20.3766 5.18192 20.3248 4.93912 20.2241C4.69632 20.1235 4.47575 19.976 4.29 19.79C4.10405 19.6043 3.95653 19.3837 3.85588 19.1409C3.75523 18.8981 3.70343 18.6378 3.70343 18.375C3.70343 18.1122 3.75523 17.8519 3.85588 17.6091C3.95653 17.3663 4.10405 17.1457 4.29 16.96L4.35 16.9C4.58054 16.6643 4.73519 16.365 4.794 16.0406C4.85282 15.7162 4.81312 15.3816 4.68 15.08C4.55324 14.7842 4.34276 14.532 4.07447 14.3543C3.80618 14.1766 3.49179 14.0813 3.17 14.08H3C2.46957 14.08 1.96086 13.8693 1.58579 13.4942C1.21071 13.1191 1 12.6104 1 12.08C1 11.5496 1.21071 11.0409 1.58579 10.6658C1.96086 10.2907 2.46957 10.08 3 10.08H3.09C3.42099 10.0723 3.742 9.96512 4.0113 9.77251C4.28059 9.5799 4.48572 9.31074 4.6 9C4.73312 8.69838 4.77282 8.36381 4.714 8.03941C4.65519 7.71502 4.50054 7.41568 4.27 7.18L4.21 7.12C4.02405 6.93425 3.87653 6.71368 3.77588 6.47088C3.67523 6.22808 3.62343 5.96783 3.62343 5.705C3.62343 5.44217 3.67523 5.18192 3.77588 4.93912C3.87653 4.69632 4.02405 4.47575 4.21 4.29C4.39575 4.10405 4.61632 3.95653 4.85912 3.85588C5.10192 3.75523 5.36217 3.70343 5.625 3.70343C5.88783 3.70343 6.14808 3.75523 6.39088 3.85588C6.63368 3.95653 6.85425 4.10405 7.04 4.29L7.1 4.35C7.33568 4.58054 7.63502 4.73519 7.95941 4.794C8.28381 4.85282 8.61838 4.81312 8.92 4.68H9C9.29577 4.55324 9.54802 4.34276 9.72569 4.07447C9.90337 3.80618 9.99872 3.49179 10 3.17V3C10 2.46957 10.2107 1.96086 10.5858 1.58579C10.9609 1.21071 11.4696 1 12 1C12.5304 1 13.0391 1.21071 13.4142 1.58579C13.7893 1.96086 14 2.46957 14 3V3.09C14.0013 3.41179 14.0966 3.72618 14.2743 3.99447C14.452 4.26276 14.7042 4.47324 15 4.6C15.3016 4.73312 15.6362 4.77282 15.9606 4.714C16.285 4.65519 16.5843 4.50054 16.82 4.27L16.88 4.21C17.0657 4.02405 17.2863 3.87653 17.5291 3.77588C17.7719 3.67523 18.0322 3.62343 18.295 3.62343C18.5578 3.62343 18.8181 3.67523 19.0609 3.77588C19.3037 3.87653 19.5243 4.02405 19.71 4.21C19.896 4.39575 20.0435 4.61632 20.1441 4.85912C20.2448 5.10192 20.2966 5.36217 20.2966 5.625C20.2966 5.88783 20.2448 6.14808 20.1441 6.39088C20.0435 6.63368 19.896 6.85425 19.71 7.04L19.65 7.1C19.4195 7.33568 19.2648 7.63502 19.206 7.95941C19.1472 8.28381 19.1869 8.61838 19.32 8.92V9C19.4468 9.29577 19.6572 9.54802 19.9255 9.72569C20.1938 9.90337 20.5082 9.99872 20.83 10H21C21.5304 10 22.0391 10.2107 22.4142 10.5858C22.7893 10.9609 23 11.4696 23 12C23 12.5304 22.7893 13.0391 22.4142 13.4142C22.0391 13.7893 21.5304 14 21 14H20.91C20.5882 14.0013 20.2738 14.0966 20.0055 14.2743C19.7372 14.452 19.5268 14.7042 19.4 15Z\"\r\n                                            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </g>\r\n                                    <defs>\r\n                                        <clipPath id=\"clip0_1017_22270\">\r\n                                            <rect width=\"24\" height=\"24\" fill=\"currentColor\" />\r\n                                        </clipPath>\r\n                                    </defs>\r\n                                </svg>\r\n\r\n                            </span>\r\n                            <span class=\"menu-title fw-bold \">Store Configuration</span>\r\n                        </span>\r\n                        <!--end::Inbox-->\r\n                    </div>\r\n\r\n                    <!--end::Menu item-->\r\n\r\n\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Draft-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'contact' }\"\r\n                            (click)=\"settingvalue('contact')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path\r\n                                        d=\"M17 21V19C17 17.9391 16.5786 16.9217 15.8284 16.1716C15.0783 15.4214 14.0609 15 13 15H5C3.93913 15 2.92172 15.4214 2.17157 16.1716C1.42143 16.9217 1 17.9391 1 19V21M23 21V19C22.9993 18.1137 22.7044 17.2528 22.1614 16.5523C21.6184 15.8519 20.8581 15.3516 20 15.13M16 3.13C16.8604 3.3503 17.623 3.8507 18.1676 4.55231C18.7122 5.25392 19.0078 6.11683 19.0078 7.005C19.0078 7.89317 18.7122 8.75608 18.1676 9.45769C17.623 10.1593 16.8604 10.6597 16 10.88M13 7C13 9.20914 11.2091 11 9 11C6.79086 11 5 9.20914 5 7C5 4.79086 6.79086 3 9 3C11.2091 3 13 4.79086 13 7Z\"\r\n                                        stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                        stroke-linejoin=\"round\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Contact Details</span>\r\n                        </span>\r\n                        <!--end::Draft-->\r\n                    </div>\r\n                    <!--end::Menu item-->\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Trash-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'review'}\"\r\n                            (click)=\"settingvalue('review')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n                                        d=\"M6 1C5.20435 1 4.44129 1.31607 3.87868 1.87868C3.31607 2.44129 3 3.20435 3 4V20C3 20.7957 3.31607 21.5587 3.87868 22.1213C4.44129 22.6839 5.20435 23 6 23H12H18C18.7957 23 19.5587 22.6839 20.1213 22.1213C20.6839 21.5587 21 20.7957 21 20V16.4208L19 18.4208V20C19 20.2652 18.8946 20.5196 18.7071 20.7071C18.5196 20.8946 18.2652 21 18 21H16.4208L15.3286 22.0922L12 23L12.5455 21H6C5.73478 21 5.48043 20.8946 5.29289 20.7071C5.10536 20.5196 5 20.2652 5 20V4C5 3.73478 5.10536 3.48043 5.29289 3.29289C5.48043 3.10536 5.73478 3 6 3H12V9C12 9.55228 12.4477 10 13 10H19V13.5792L21 11.5792V9C21 8.73478 20.8946 8.48043 20.7071 8.29289L13.7071 1.29289C13.5196 1.10536 13.2652 1 13 1H6ZM17.5858 8L14 4.41421V8H17.5858Z\"\r\n                                        fill=\"currentColor\" />\r\n                                    <path\r\n                                        d=\"M20.0779 11.5014C20.2369 11.3424 20.4256 11.2163 20.6333 11.1303C20.8409 11.0443 21.0635 11 21.2883 11C21.5131 11 21.7357 11.0443 21.9434 11.1303C22.151 11.2163 22.3397 11.3424 22.4987 11.5014C22.6576 11.6603 22.7837 11.849 22.8698 12.0567C22.9558 12.2644 23.0001 12.487 23.0001 12.7117C23.0001 12.9365 22.9558 13.1591 22.8698 13.3668C22.7837 13.5745 22.6576 13.7632 22.4987 13.9221L15.3286 22.0923L12 23.0001L12.9078 19.6715L20.0779 11.5014Z\"\r\n                                        stroke=\"currentColor\" stroke-width=\"1.6\" stroke-linecap=\"round\"\r\n                                        stroke-linejoin=\"round\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Review & Submit</span>\r\n                        </span>\r\n                        <!--end::Trash-->\r\n                    </div>\r\n                    <!--end::Menu item-->\r\n\r\n\r\n                </div>\r\n            </div>\r\n            <!--end::Menu-->\r\n        </div>\r\n    </div>\r\n    <div class=\"col-md-9 col-lg-9 col-xl-9 col-xxl-9\">\r\n        <div class=\"card\">\r\n            <div class=\"card-header border-bottom-0\">\r\n                <h1\r\n                    class=\"page-heading d-flex text-dark fw-bold fs-2 flex-column  justify-content-center my-0 sub-head\">\r\n                    <span  *ngIf=\"select === 'store_info'\">Enter Your Store Details</span>\r\n                    <span *ngIf=\"select === 'config'\">Enter Your Store Configuration</span>\r\n                    <span *ngIf=\"select === 'contact'\">Enter Primary SPOC details</span>\r\n                    <span *ngIf=\"select === 'review'\">Review & submit</span>\r\n                </h1>\r\n                <div [hidden]=\"select !== 'contact'\" class=\"card-toolbar\">\r\n                    <button (click)=\"addAltSpoc()\" class=\"btn btn-light-primary1 btn-sm\"><svg class=\"me-2\"\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"14\" viewBox=\"0 0 18 14\" fill=\"none\">\r\n                            <path\r\n                                d=\"M2.7 3.5C2.7 2.57174 3.07928 1.6815 3.75442 1.02513C4.42955 0.368749 5.34522 0 6.3 0C7.25478 0 8.17045 0.368749 8.84558 1.02513C9.52072 1.6815 9.9 2.57174 9.9 3.5C9.9 4.42826 9.52072 5.3185 8.84558 5.97487C8.17045 6.63125 7.25478 7 6.3 7C5.34522 7 4.42955 6.63125 3.75442 5.97487C3.07928 5.3185 2.7 4.42826 2.7 3.5ZM0 13.1879C0 10.4945 2.24437 8.3125 5.01469 8.3125H7.58531C10.3556 8.3125 12.6 10.4945 12.6 13.1879C12.6 13.6363 12.2259 14 11.7647 14H0.835312C0.374063 14 0 13.6363 0 13.1879ZM14.175 8.53125V6.78125H12.375C12.0009 6.78125 11.7 6.48867 11.7 6.125C11.7 5.76133 12.0009 5.46875 12.375 5.46875H14.175V3.71875C14.175 3.35508 14.4759 3.0625 14.85 3.0625C15.2241 3.0625 15.525 3.35508 15.525 3.71875V5.46875H17.325C17.6991 5.46875 18 5.76133 18 6.125C18 6.48867 17.6991 6.78125 17.325 6.78125H15.525V8.53125C15.525 8.89492 15.2241 9.1875 14.85 9.1875C14.4759 9.1875 14.175 8.89492 14.175 8.53125Z\"\r\n                                fill=\"#00A3FF\" />\r\n                        </svg>Add Alternate SPOC</button>\r\n                </div>\r\n            </div>\r\n            <div class=\"card-body pt-1\">\r\n                <form [formGroup]=\"storeForm\">\r\n                    <!-- Store Info Start -->\r\n                    <div [hidden]=\"select !== 'store_info'\">\r\n                        <div class=\"row\">\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeName\" class=\"form-label\">Store Name</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"storeName\" formControlName=\"storeName\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('storeName')?.invalid && storeForm.get('storeName')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('storeName')?.touched && storeForm.get('storeName')?.hasError('required')\">\r\n                                    Store Name is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeCode\" class=\"form-label\">Store Code / Ref Code (optional)</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"storeCode\" formControlName=\"storeCode\">\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"businessType\" class=\"form-label\">Business Type</label>\r\n                                <select class=\"form-select\" id=\"businessType\" formControlName=\"businessType\">\r\n                                    <option value=\"COCO\">COCO</option>\r\n                                    <option value=\"COFO\">COFO</option>\r\n                                    <option value=\"FOFO\">FOFO</option>\r\n                                    <option value=\"FOCO\">FOCO</option>\r\n                                </select>\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeType\" class=\"form-label\">Store Type</label>\r\n                                <select class=\"form-select\" id=\"storeType\" formControlName=\"storeType_type\">\r\n                                    <option value=\"High Street\">High Street</option>\r\n                                    <option value=\"Mall Store\">Mall Store</option>\r\n                                    <option value=\"Kiosk\">Kiosk</option>\r\n                                </select>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\" *ngIf=\"storeForm.get('storeType_type')?.value === 'Mall Store'\">\r\n                                <label for=\"mallName\" class=\"form-label\">Enter Mall Name</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"mallName\" formControlName=\"storeType_name\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('storeType_name')?.invalid && storeForm.get('storeType_name')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('storeType_name')?.touched && storeForm.get('storeType_name')?.hasError('required')\">\r\n                                    Mall Name is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <label for=\"address\" class=\"form-label\">Address Line</label>\r\n                                <input type=\"text\" class=\"form-control\" id=\"address\" formControlName=\"address\" #placesRef=\"ngx-places\" ngx-gp-autocomplete (onAddressChange)=\"handleAddressChange($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('address')?.invalid && storeForm.get('address')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('address')?.touched && storeForm.get('address')?.hasError('required')\">\r\n                                    Address is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"country\" class=\"form-label\">Country</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"country\" formControlName=\"country\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('country')?.invalid && storeForm.get('country')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('country')?.touched && storeForm.get('country')?.hasError('required')\">\r\n                                    Country is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"state\" class=\"form-label\">State</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"state\" formControlName=\"state\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('state')?.invalid && storeForm.get('state')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('state')?.touched && storeForm.get('state')?.hasError('required')\">\r\n                                    State is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"city\" class=\"form-label\">City / Town</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"city\" formControlName=\"city\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('city')?.invalid && storeForm.get('city')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('city')?.touched && storeForm.get('city')?.hasError('required')\">\r\n                                    City is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"pincode\" class=\"form-label\">Pin / Zip Code</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"pincode\" formControlName=\"pincode\" maxlength=\"6\" minlength=\"6\" (keypress)=\"omit_special_char($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('pincode')?.invalid && storeForm.get('pincode')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('pincode')?.touched && storeForm.get('pincode')?.hasError('required')\">\r\n                                    Pincode is required.\r\n                                </small>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"col-12 text-end\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\"\r\n                                    (click)=\"goToConfiguration()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Info End -->\r\n\r\n                    <!-- Store Configuration Start -->\r\n                    <div [hidden]=\"select !== 'config'\">\r\n                        <div class=\"row\">\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"timeZone\" class=\"form-label\">Time Zone</label>\r\n                                <!-- <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"timeZone\" formControlName=\"timeZone\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('timeZone')?.invalid && storeForm.get('timeZone')?.touched}\"> -->\r\n                                    <select class=\"form-select\" id=\"timeZone\" formControlName=\"timeZone\">\r\n                                        <option *ngFor=\"let timezone of timezones\" [value]=\"timezone\">{{ timezone }}</option>\r\n                                    </select>\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('timeZone')?.touched && storeForm.get('timeZone')?.hasError('required')\">\r\n                                    Time Zone is required.\r\n                                </small>\r\n                            </div>\r\n                            <!-- <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"noOfCameras\" class=\"form-label\">No of Cameras</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"noOfCameras\" formControlName=\"cameras\" (keypress)=\"omit_special_char($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('cameras')?.invalid && storeForm.get('cameras')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('cameras')?.touched && storeForm.get('cameras')?.hasError('required')\">\r\n                                    No of Cameras is required.\r\n                                </small>\r\n                            </div> -->\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"storeOpenTime\" class=\"form-label\">Store Open Time</label>\r\n                                <input autocomplete=\"off\" type=\"time\" class=\"form-control\" id=\"storeOpenTime\" formControlName=\"open\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('open')?.invalid && storeForm.get('open')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('open')?.touched && storeForm.get('open')?.hasError('required')\">\r\n                                    Store Open Time is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"storeCloseTime\" class=\"form-label\">Store Close Time</label>\r\n                                <input autocomplete=\"off\" type=\"time\" class=\"form-control\" id=\"storeCloseTime\" formControlName=\"close\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('close')?.invalid && storeForm.get('close')?.touched || storeForm.hasError('invalidTimeRange')}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('close')?.touched && storeForm.get('close')?.hasError('required')\">\r\n                                    Store Close Time is required.\r\n                                </small>\r\n                                <small class=\"my-2\" *ngIf=\"storeForm.hasError('invalidTimeRange') && (storeForm.get('open')?.touched || storeForm.get('close')?.touched)\">\r\n                                    Opening time must be before closing time.\r\n                                </small>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row mt-20\">\r\n                            <div class=\"col-12 text-end mt-15\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\" (click)=\"goToContact()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Configuration End -->\r\n\r\n                    <!-- Store Contact Start -->\r\n                    <div [hidden]=\"select !== 'contact'\">\r\n                        <div class=\"row\">\r\n                            <ng-container formArrayName=\"spocDetails\">\r\n                                <ng-container *ngFor=\"let spocDetail of getspocDetailsControls(); let i = index\" [formGroupName]=\"i\">\r\n                                    <div *ngIf=\"i!==0\" class=\"d-flex justify-content-between align-items-center my-6\">\r\n                                        <ng-container >\r\n                                            <span class=\"fw-bold fs-4\">Alternate SPOC {{i}}</span>\r\n                                            <span (click)=\"delAltSpoc()\">\r\n                                                <svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <g filter=\"url(#filter0_d_2250_30650)\">\r\n                                                        <rect x=\"2\" y=\"1\" width=\"36\" height=\"36\" rx=\"8\" fill=\"white\" />\r\n                                                        <rect x=\"2.5\" y=\"1.5\" width=\"35\" height=\"35\" rx=\"7.5\" stroke=\"#D0D5DD\" />\r\n                                                        <path\r\n                                                            d=\"M12.5 13.9998H14.1667M14.1667 13.9998H27.5M14.1667 13.9998V25.6665C14.1667 26.1085 14.3423 26.5325 14.6548 26.845C14.9674 27.1576 15.3913 27.3332 15.8333 27.3332H24.1667C24.6087 27.3332 25.0326 27.1576 25.3452 26.845C25.6577 26.5325 25.8333 26.1085 25.8333 25.6665V13.9998H14.1667ZM16.6667 13.9998V12.3332C16.6667 11.8911 16.8423 11.4672 17.1548 11.1547C17.4674 10.8421 17.8913 10.6665 18.3333 10.6665H21.6667C22.1087 10.6665 22.5326 10.8421 22.8452 11.1547C23.1577 11.4672 23.3333 11.8911 23.3333 12.3332V13.9998M18.3333 18.1665V23.1665M21.6667 18.1665V23.1665\"\r\n                                                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                    </g>\r\n                                                    <defs>\r\n                                                        <filter id=\"filter0_d_2250_30650\" x=\"0\" y=\"0\" width=\"40\" height=\"40\"\r\n                                                            filterUnits=\"userSpaceOnUse\" color-interpolation-filters=\"sRGB\">\r\n                                                            <feFlood flood-opacity=\"0\" result=\"BackgroundImageFix\" />\r\n                                                            <feColorMatrix in=\"SourceAlpha\" type=\"matrix\"\r\n                                                                values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0\" result=\"hardAlpha\" />\r\n                                                            <feOffset dy=\"1\" />\r\n                                                            <feGaussianBlur stdDeviation=\"1\" />\r\n                                                            <feColorMatrix type=\"matrix\"\r\n                                                                values=\"0 0 0 0 0.0627451 0 0 0 0 0.0941176 0 0 0 0 0.156863 0 0 0 0.05 0\" />\r\n                                                            <feBlend mode=\"normal\" in2=\"BackgroundImageFix\" result=\"effect1_dropShadow_2250_30650\" />\r\n                                                            <feBlend mode=\"normal\" in=\"SourceGraphic\" in2=\"effect1_dropShadow_2250_30650\"\r\n                                                                result=\"shape\" />\r\n                                                        </filter>\r\n                                                    </defs>\r\n                                                </svg>\r\n                                            </span>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactName\" class=\"form-label\">Name</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"contactName\" formControlName=\"name\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('name')?.invalid && spocDetail.get('name')?.touched}\">\r\n                                        <small class=\"invalid-feedback\"\r\n                                            *ngIf=\"spocDetail.get('name')?.touched && spocDetail.get('name')?.hasError('required')\">\r\n                                            Name is required.\r\n                                        </small>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactEmail\" class=\"form-label\">Email</label>\r\n                                        <input autocomplete=\"off\" type=\"email\" class=\"form-control\" id=\"contactEmail\" formControlName=\"email\"\r\n                                            pattern=\"^([a-zA-Z0-9_\\-\\.]+)@[a-z0-9-]+(\\.[a-z0-9-]+)*(\\.[a-zA-Z]{2,3})$\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('email')?.invalid && spocDetail.get('email')?.touched}\">\r\n                                        <ng-container *ngIf=\"spocDetail.get('email')?.touched\">\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('required')\">\r\n                                                Email is required.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('minlength')\">\r\n                                                Email must be at least 3 characters long.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('maxlength')\">\r\n                                                Email must be not more than 100 characters long.\r\n                                            </small>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactNumber\" class=\"form-label\">Contact Number</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"contactNumber\" minlength=\"10\" maxlength=\"13\"\r\n                                            (keypress)=\"omit_special_char($event)\" formControlName=\"contact\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('contact')?.invalid && spocDetail.get('contact')?.touched}\">\r\n                                        <ng-container *ngIf=\"spocDetail.get('contact')?.touched\">\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('required')\">\r\n                                                Contact is required.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('minlength')\">\r\n                                                Contact must be at least 10 digits.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('maxlength')\">\r\n                                                Contact must be not more than 13 digits.\r\n                                            </small>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"designation\" class=\"form-label\">Designation (optional)</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"designation\" formControlName=\"designation\">\r\n                                    </div>\r\n                                </ng-container>\r\n                            </ng-container>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <h1 class=\"sub-head\">Enter Store Connection Details</h1>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <label for=\"anyDeskID\" class=\"form-label\">AnyDesk ID / TeamViewer ID (optional)</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"anyDeskID\"\r\n                                    formControlName=\"storeConnectionId\">\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"col-12 text-end\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\" (click)=\"goToReview()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Contact End -->\r\n\r\n                    <!-- Review & Submit Start -->\r\n                    <div [hidden]=\"select !== 'review'\">\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Store\r\n                            Info\r\n                        </div>\r\n                        <div class=\"card-body p-9\">\r\n\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Name</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('storeName')?.value ?\r\n                                        storeForm.get('storeName')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Code</label>\r\n                                <div class=\"col-lg-9 fv-row\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val\">{{storeForm.get('storeCode')?.value ?\r\n                                        storeForm.get('storeCode')?.value: 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                                                           \r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Business Type</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val text-hover-primary\">\r\n                                        {{storeForm.get('businessType')?.value ? storeForm.get('businessType')?.value :\r\n                                        'NA'}} </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Type\r\n                                    <!-- <i data-bs-toggle=\"tooltip\"\r\n                                        title=\"Phone number must be active\" class=\"fas fa-exclamation-circle ms-1 fs-7\"></i> -->\r\n                                </label>\r\n                                <div class=\"col-lg-9 d-flex align-items-center\">\r\n                                    <span\r\n                                        class=\"fw-bolder fs-6 me-2 text-review-val\">{{storeForm.get('storeType_type')?.value\r\n                                        ? storeForm.get('storeType_type')?.value : 'NA'}}</span>\r\n                                    <!-- <span class=\"badge badge-success\">Verified</span> -->\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\"\r\n                                *ngIf=\"storeForm.get('storeType_type')?.value && storeForm.get('storeType_type')?.value === 'Mall Store'\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\"> Mall Name</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('storeType_name')?.value\r\n                                        ? storeForm.get('storeType_name')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Address</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">\r\n                                        <ng-container>\r\n                                            {{storeForm.get('address')?.value ? storeForm.get('address')?.value : 'NA'}}\r\n                                        </ng-container>\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <!-- <div class=\"row mb-10\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Allow Changes</label>\r\n                                <div class=\"col-lg-9\"><span class=\"fw-bold fs-6\">Yes</span></div>\r\n                            </div> -->\r\n\r\n                        </div>\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Store\r\n                            Configuration</div>\r\n                        <div class=\"card-body p-9\">\r\n\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Time Zone</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('timeZone')?.value ?\r\n                                        storeForm.get('timeZone')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <!-- <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">No of Cameras</label>\r\n                                <div class=\"col-lg-9 fv-row\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val\">{{storeForm.get('cameras')?.value ?\r\n                                        storeForm.get('cameras')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div> -->\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Open Time</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val text-hover-primary\">{{storeForm.get('open')?.value\r\n                                        ? storeForm.get('open')?.value : 'NA'}}\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Close Time</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('close')?.value ?\r\n                                        storeForm.get('close')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n\r\n                        </div>\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Contact\r\n                            Details</div>\r\n                        <div class=\"card-body row px-9 pt-3 pb-4\">\r\n                            <div class=\"table-responsive col-md-12 col-lg-12 col-xl-9 col-xxl-8\">\r\n                                <table class=\"table align-middle gy-6\">\r\n                                    <tbody class=\"fs-6 fw-bold\"> \r\n                                        <ng-container formArrayName=\"spocDetails\">\r\n                                            <ng-container *ngFor=\"let spoc of getspocDetailsControls();let i=index;\">\r\n                                                <tr>\r\n                                                    <td>Spoc {{i+1}}</td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <path\r\n                                                                d=\"M15 15.75V14.25C15 13.4544 14.6839 12.6913 14.1213 12.1287C13.5587 11.5661 12.7956 11.25 12 11.25H6C5.20435 11.25 4.44129 11.5661 3.87868 12.1287C3.31607 12.6913 3 13.4544 3 14.25V15.75M12 5.25C12 6.90685 10.6569 8.25 9 8.25C7.34315 8.25 6 6.90685 6 5.25C6 3.59315 7.34315 2.25 9 2.25C10.6569 2.25 12 3.59315 12 5.25Z\"\r\n                                                                stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.name ?\r\n                                                            getspocDetailsValues(i)?.name : 'NA' }}</span></td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <g clip-path=\"url(#clip0_1_80373)\">\r\n                                                                <path\r\n                                                                    d=\"M12 6.00002V9.75002C12 10.3468 12.2371 10.9191 12.659 11.341C13.081 11.763 13.6533 12 14.25 12C14.8467 12 15.419 11.763 15.841 11.341C16.263 10.9191 16.5 10.3468 16.5 9.75002V9.00002C16.4999 7.30729 15.9272 5.66438 14.875 4.33842C13.8227 3.01246 12.3529 2.08144 10.7045 1.69675C9.05605 1.31205 7.32596 1.4963 5.79552 2.21955C4.26508 2.94279 3.02431 4.16249 2.27495 5.68032C1.5256 7.19814 1.31173 8.92483 1.66813 10.5796C2.02453 12.2344 2.93024 13.7199 4.23798 14.7947C5.54572 15.8695 7.17858 16.4703 8.87106 16.4994C10.5635 16.5285 12.2161 15.9842 13.56 14.955M12 9.00002C12 10.6569 10.6569 12 9.00001 12C7.34315 12 6.00001 10.6569 6.00001 9.00002C6.00001 7.34317 7.34315 6.00002 9.00001 6.00002C10.6569 6.00002 12 7.34317 12 9.00002Z\"\r\n                                                                    stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                            </g>\r\n                                                            <defs>\r\n                                                                <clipPath id=\"clip0_1_80373\">\r\n                                                                    <rect width=\"18\" height=\"18\" fill=\"white\" />\r\n                                                                </clipPath>\r\n                                                            </defs>\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.email ?\r\n                                                            getspocDetailsValues(i)?.email : 'NA' }}</span></td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <g clip-path=\"url(#clip0_1_80376)\">\r\n                                                                <path\r\n                                                                    d=\"M16.5001 12.6901V14.9401C16.5009 15.1489 16.4581 15.3557 16.3745 15.5471C16.2908 15.7385 16.168 15.9103 16.0141 16.0515C15.8602 16.1927 15.6785 16.3002 15.4806 16.3671C15.2828 16.434 15.0731 16.4589 14.8651 16.4401C12.5572 16.1893 10.3403 15.4007 8.39257 14.1376C6.58044 12.9861 5.04407 11.4497 3.89257 9.63757C2.62506 7.68098 1.83625 5.45332 1.59007 3.13507C1.57133 2.92767 1.59598 2.71864 1.66245 2.52129C1.72892 2.32394 1.83575 2.14259 1.97615 1.98879C2.11654 1.83499 2.28743 1.7121 2.47792 1.62796C2.6684 1.54382 2.87433 1.50027 3.08257 1.50007H5.33257C5.69655 1.49649 6.04942 1.62538 6.32539 1.86272C6.60137 2.10006 6.78163 2.42966 6.83257 2.79007C6.92754 3.51012 7.10366 4.21712 7.35757 4.89757C7.45848 5.16602 7.48032 5.45776 7.4205 5.73823C7.36069 6.01871 7.22172 6.27616 7.02007 6.48007L6.06757 7.43257C7.13524 9.31023 8.68991 10.8649 10.5676 11.9326L11.5201 10.9801C11.724 10.7784 11.9814 10.6395 12.2619 10.5796C12.5424 10.5198 12.8341 10.5417 13.1026 10.6426C13.783 10.8965 14.49 11.0726 15.2101 11.1676C15.5744 11.219 15.9071 11.4025 16.145 11.6832C16.3828 11.9639 16.5092 12.3223 16.5001 12.6901Z\"\r\n                                                                    stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                            </g>\r\n                                                            <defs>\r\n                                                                <clipPath id=\"clip0_1_80376\">\r\n                                                                    <rect width=\"18\" height=\"18\" fill=\"white\" />\r\n                                                                </clipPath>\r\n                                                            </defs>\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.contact ?\r\n                                                            getspocDetailsValues(i)?.contact : 'NA' }}</span></td>\r\n                                                </tr>\r\n                                            </ng-container>\r\n                                        </ng-container>\r\n                                        <tr>\r\n                                            <td>AnyDesk ID\r\n                                            <td>\r\n                                                <span class=\"ms-2\">{{storeForm.get('storeConnectionId')?.value ?\r\n                                                    storeForm.get('storeConnectionId')?.value : 'NA' }}</span>\r\n                                            </td>\r\n                                        </tr>\r\n                                    </tbody>\r\n                                </table>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"text-end\">\r\n                                <button type=\"button\" (click)=\"goToStoreInfo()\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\">Edit</button>\r\n                                <button type=\"button\" [disabled]=\"storeForm.invalid\" (click)=\"onSubmit()\"\r\n                                    class=\"btn btn-primary\">Submit</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Review & Submit End -->\r\n                </form>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-stores-form.component.js","sourceRoot":"","sources":["../../../../../../projects/tango-manage-stores/src/lib/components/add-stores-form/add-stores-form.component.ts","../../../../../../projects/tango-manage-stores/src/lib/components/add-stores-form/add-stores-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  OnInit,\r\n  ViewChild,\r\n} from \"@angular/core\";\r\nimport { FormBuilder, FormArray, Validators, FormGroup, AbstractControl, ValidationErrors } from \"@angular/forms\";\r\nimport { StoresService } from \"../../services/stores.service\";\r\nimport { HttpErrorResponse } from \"@angular/common/http\";\r\nimport { StoreResponse } from \"../../interfaces/store.interface\";\r\nimport { Router } from \"@angular/router\";\r\nimport * as moment from 'moment-timezone';\r\nimport { NgxGpAutocompleteDirective } from \"@angular-magic/ngx-gp-autocomplete/lib/ngx-gp-autocomplete.directive\";\r\nimport { ToastService } from \"tango-app-ui-shared\";\r\n\r\ndeclare var $: any;\r\n\r\n@Component({\r\n  selector: \"lib-add-stores-form\",\r\n  templateUrl: \"./add-stores-form.component.html\",\r\n  styleUrl: \"./add-stores-form.component.scss\",\r\n})\r\nexport class AddStoresFormComponent implements OnInit {\r\n  @ViewChild(\"ngxPlaces\") placesRef: NgxGpAutocompleteDirective;\r\n\r\n  select = \"store_info\";\r\n  storeForm: FormGroup;\r\n  storeId: string;\r\n  timezones: any[];\r\n  $headerFilters: any;\r\n\r\n  public handleAddressChange(place: google.maps.places.PlaceResult | any) {\r\n    if (place.geometry) {\r\n      let country = \"\", city = \"\", state = \"\", pincode = \"\";\r\n      place.address_components.forEach((component: any) => {\r\n        if (component.types.includes(\"country\")) {\r\n          country = component.long_name;\r\n        } else if (component.types.includes(\"locality\")) {\r\n          city = component.long_name;\r\n        } else if (component.types.includes(\"administrative_area_level_1\")) {\r\n          state = component.long_name;\r\n        } else if (component.types.includes(\"postal_code\")) {\r\n          pincode = component.long_name;\r\n        }\r\n      });\r\n      this.storeForm.get('address')?.setValue(place.formatted_address);\r\n      this.storeForm.get(\"country\")?.setValue(country);\r\n      this.storeForm.get(\"city\")?.setValue(city);\r\n      this.storeForm.get(\"state\")?.setValue(state);\r\n      this.storeForm.get(\"pincode\")?.setValue(pincode);\r\n    }\r\n  }\r\n\r\n  constructor(\r\n    private fb: FormBuilder,\r\n    private storesService: StoresService,\r\n    private ts: ToastService,\r\n    private router: Router\r\n  ) {\r\n    let data:any = JSON.parse(localStorage.getItem('header-filters') || '');\r\n    this.$headerFilters = data;\r\n    this.getAllTimezones();\r\n    this.createForm();\r\n  }\r\n\r\n  ngOnInit() {}\r\n\r\n  settingvalue(label: any) {\r\n    if (label == \"store_info\") {\r\n      this.select = \"store_info\";\r\n    } else if (label == \"config\") {\r\n      this.select = \"config\";\r\n    } else if (label == \"store_loc\") {\r\n      this.select = \"store_loc\";\r\n    } else if (label == \"contact\") {\r\n      this.select = \"contact\";\r\n    } else if (label == \"review\") {\r\n      this.select = \"review\";\r\n    }\r\n  }\r\n\r\n  createForm() {\r\n    this.storeForm = this.fb.group(\r\n      {\r\n        storeName: [\"\", Validators.required],\r\n        clientId: [this.$headerFilters?.client, Validators.required],\r\n        businessType: [\"COCO\", Validators.required],\r\n        storeType_type: [\"High Street\", Validators.required],\r\n        storeType_name: [\"\"],\r\n        storeCode: [\"\"],\r\n        address: [\"\", Validators.required],\r\n        country: [\"\", Validators.required],\r\n        state: [\"\", Validators.required],\r\n        city: [\"\", Validators.required],\r\n        pincode: [\"\", Validators.required],\r\n        timeZone: [\"Asia/Kolkata\", Validators.required],\r\n        open: [\"10:00\", Validators.required],\r\n        close: [\"20:00\", Validators.required],\r\n        // cameras: [0, Validators.required],\r\n        spocDetails: this.fb.array([this.createSpocDetail()]),\r\n        storeConnectionId: [\"\"],\r\n      },\r\n      { validators: this.timeRangeValidator }\r\n    );\r\n  }\r\n\r\n  timeRangeValidator(control: AbstractControl): ValidationErrors | null {\r\n    const openTime = control.get(\"open\")?.value;\r\n    const closeTime = control.get(\"close\")?.value;\r\n    if (openTime && closeTime && openTime >= closeTime) {\r\n      return { invalidTimeRange: true };\r\n    }    \r\n    return null;\r\n  }\r\n\r\n  createSpocDetail(): FormGroup {\r\n    return this.fb.group({\r\n      name: [\"\", Validators.required],\r\n      email: [\r\n        \"\",\r\n        [\r\n          Validators.required,\r\n          Validators.email,\r\n          Validators.maxLength(100),\r\n          Validators.minLength(3),\r\n        ],\r\n      ],\r\n      contact: [\r\n        \"\",\r\n        [\r\n          Validators.required,\r\n          Validators.maxLength(13),\r\n          Validators.minLength(10),\r\n        ],\r\n      ],\r\n      designation: [\"\"],\r\n    });\r\n  }\r\n\r\n  getspocDetailsControls() {\r\n    return (this.storeForm.get(\"spocDetails\") as FormArray).controls;\r\n  }\r\n\r\n  getspocDetailsValues(i: number) {\r\n    return (this.storeForm.get(\"spocDetails\") as FormArray).at(i).value;\r\n  }\r\n\r\n  getStoreProfile(): FormGroup {\r\n    return this.storeForm.get(\"storeProfile\") as FormGroup;\r\n  }\r\n\r\n  goToStoreInfo(): void {\r\n    this.select = \"store_info\";\r\n  }\r\n\r\n  goToConfiguration(): void {\r\n    this.select = \"config\";\r\n  }\r\n\r\n  goToContact(): void {\r\n    this.select = \"contact\";\r\n  }\r\n\r\n  goToReview(): void {\r\n    this.select = \"review\";\r\n  }\r\n\r\n  addSpocDetail() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).push(\r\n      this.createSpocDetail()\r\n    );\r\n  }\r\n\r\n  addAltSpoc() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).push(\r\n      this.createSpocDetail()\r\n    );\r\n  }\r\n\r\n  delAltSpoc() {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).removeAt(1);\r\n  }\r\n\r\n  removeSpocDetail(index: number) {\r\n    (this.storeForm.get(\"spocDetails\") as FormArray).removeAt(index);\r\n  }\r\n\r\n  onSubmit() {\r\n    if (this.storeForm.valid) {\r\n      let store: StoreResponse = {\r\n        storeName: this.storeForm.value.storeName,\r\n        clientId: this.storeForm.value.clientId,\r\n        businessType: this.storeForm.value.businessType,\r\n        storeType: {\r\n          type: this.storeForm.value.storeType_type,\r\n          name: this.storeForm.value?.storeType_name,\r\n        },\r\n        storeProfile: {\r\n          storeCode: this.storeForm.value?.storeCode,\r\n          address: this.storeForm.value?.address,\r\n          country: this.storeForm.value?.country,\r\n          state: this.storeForm.value?.state,\r\n          city: this.storeForm.value?.city,\r\n          pincode: this.storeForm.value?.pincode,\r\n          timeZone: this.storeForm.value?.timeZone,\r\n          open: this.storeForm.value?.open,\r\n          close: this.storeForm.value?.close,\r\n        },\r\n        // edge: {\r\n        //   camDetails: {\r\n        //     cameras: this.storeForm.value?.cameras,\r\n        //   },\r\n        // },\r\n        spocDetails: [\r\n          {\r\n            name: this.storeForm.value?.spocDetails[0].name,\r\n            email: this.storeForm.value?.spocDetails[0].email,\r\n            contact: this.storeForm.value?.spocDetails[0].contact,\r\n            designation: this.storeForm.value?.spocDetails[0].designation,\r\n          },\r\n        ],\r\n        storeConnectionId: this.storeForm.value?.storeConnectionId,\r\n      };\r\n      if (this.storeForm.value.spocDetails.length > 1) {\r\n        for(let i=1;i<this.storeForm.value.spocDetails.length;i++) {\r\n          store.spocDetails.push({\r\n            name: this.storeForm.value?.spocDetails[i].name,\r\n            email: this.storeForm.value?.spocDetails[i].email,\r\n            contact: this.storeForm.value?.spocDetails[i].contact,\r\n            designation: this.storeForm.value?.spocDetails[i].designation,\r\n          });\r\n        }\r\n      }\r\n\r\n      this.storesService.createStore(store).subscribe({\r\n        next: (res: any) => {\r\n          if (res && res.code === 200 && res.status === \"success\") {\r\n            this.ts.getSuccessToast(\"Store Created Successfully!\");\r\n            if (res.data.store && res.data.store.storeId) {\r\n              this.storesService\r\n                .createInfraTicket({\r\n                  storeId: res.data.store.storeId,\r\n                  Date: new Date().toISOString().split(\"T\")[0],\r\n                  issueType: \"installation\",\r\n                })\r\n                .subscribe({\r\n                  next: (res: any) => {},\r\n                  error: () => {},\r\n                });\r\n            }\r\n            this.router.navigate([\"/manage/stores\"]);\r\n          } else {\r\n            this.ts.getErrorToast(\"Unable to create store!\");\r\n          }\r\n        \r\n        },\r\n       error: (error: any) => {\r\n          this.ts.getErrorToast(error?.error?.error ?error?.error?.error: \"Unable to create Store!\");\r\n        }\r\n    });\r\n    } else {\r\n    }\r\n  }\r\n\r\n  navigateToAddStore() {\r\n    this.router.navigate([\"/manage/stores/addition-method\"]);\r\n  }\r\n\r\n  omit_special_char(event: any) {\r\n    var k;\r\n    k = event.charCode; //         k = event.keyCode;  (Both can be used)\r\n    return k == 8 || k == 32 || (k >= 48 && k <= 57);\r\n  }\r\n\r\n  getAllTimezones() {\r\n    this.timezones=moment.tz.names();\r\n  }\r\n}\r\n","<div class=\"row mt-3 mb-6\">\r\n    <div class=\"col-md-3 col-lg-3 col-xl-3 col-xxl-3\" id=\"left-container\">\r\n        <div class=\"card card-flush h-100 mb-0\">\r\n            <!--begin::Aside content-->\r\n            <div class=\"card-body\">\r\n                <div\r\n                    class=\"menu menu-column menu-rounded menu-state-bg menu-state-title-primary menu-state-icon-primary menu-state-bullet-primary\">\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Inbox-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'store_info' }\"\r\n                            (click)=\"settingvalue('store_info')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path stroke=\"currentColor\"\r\n                                        d=\"M3.08995 6.88369L3.02401 6.98669C2.30358 8.25557 3.06101 9.87945 4.46464 10.0662C4.58627 10.0811 4.70112 10.0892 4.8145 10.0892C5.55255 10.0892 6.20523 9.77229 6.65953 9.27917L7.21286 8.67854L7.76432 9.28089C8.21367 9.77171 8.8652 10.0892 9.60776 10.0892C10.3471 10.0892 11.0022 9.77137 11.4512 9.28089L12.0044 8.67665L12.5576 9.28089C13.0066 9.77137 13.6617 10.0892 14.401 10.0892C15.1404 10.0892 15.7954 9.77137 16.2445 9.28089L16.7977 8.67665L17.3508 9.28089C17.7999 9.77137 18.4549 10.0892 19.1943 10.0892C19.3041 10.0892 19.4223 10.0811 19.5433 10.0663C20.9772 9.87168 21.7355 8.16387 20.9155 6.88419C20.9154 6.88413 20.9154 6.88407 20.9154 6.88402L18.8056 3.59429L18.8056 3.59429L18.8046 3.59282C18.7582 3.52002 18.6649 3.46423 18.5584 3.46423H5.44307C5.3365 3.46423 5.24326 3.52002 5.19681 3.59282L5.19619 3.59379L3.08995 6.88369ZM4.81818 12.7499C4.71644 12.7499 4.616 12.7468 4.5169 12.741V16.6428V18.9642C4.5169 19.8211 5.22663 20.5357 6.11942 20.5357H17.882C18.7748 20.5357 19.4845 19.8211 19.4845 18.9642V16.6428V12.7415C19.3874 12.747 19.2893 12.7499 19.1906 12.7499C19.0022 12.7499 18.8157 12.7398 18.632 12.7202V16.6428V17.3928H17.882H6.11942H5.36942V16.6428V12.721C5.18866 12.74 5.00472 12.7499 4.81818 12.7499Z\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Store Info</span>\r\n                        </span>\r\n                        <!--end::Inbox-->\r\n                    </div>\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Inbox-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'config' }\"\r\n                            (click)=\"settingvalue('config')\">\r\n                            <span class=\"menu-icon\">\r\n                                <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\" viewBox=\"0 0 24 24\"\r\n                                    fill=\"none\">\r\n                                    <g clip-path=\"url(#clip0_1017_22270)\">\r\n                                        <path\r\n                                            d=\"M12 15C13.6569 15 15 13.6569 15 12C15 10.3431 13.6569 9 12 9C10.3431 9 9 10.3431 9 12C9 13.6569 10.3431 15 12 15Z\"\r\n                                            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                        <path\r\n                                            d=\"M19.4 15C19.2669 15.3016 19.2272 15.6362 19.286 15.9606C19.3448 16.285 19.4995 16.5843 19.73 16.82L19.79 16.88C19.976 17.0657 20.1235 17.2863 20.2241 17.5291C20.3248 17.7719 20.3766 18.0322 20.3766 18.295C20.3766 18.5578 20.3248 18.8181 20.2241 19.0609C20.1235 19.3037 19.976 19.5243 19.79 19.71C19.6043 19.896 19.3837 20.0435 19.1409 20.1441C18.8981 20.2448 18.6378 20.2966 18.375 20.2966C18.1122 20.2966 17.8519 20.2448 17.6091 20.1441C17.3663 20.0435 17.1457 19.896 16.96 19.71L16.9 19.65C16.6643 19.4195 16.365 19.2648 16.0406 19.206C15.7162 19.1472 15.3816 19.1869 15.08 19.32C14.7842 19.4468 14.532 19.6572 14.3543 19.9255C14.1766 20.1938 14.0813 20.5082 14.08 20.83V21C14.08 21.5304 13.8693 22.0391 13.4942 22.4142C13.1191 22.7893 12.6104 23 12.08 23C11.5496 23 11.0409 22.7893 10.6658 22.4142C10.2907 22.0391 10.08 21.5304 10.08 21V20.91C10.0723 20.579 9.96512 20.258 9.77251 19.9887C9.5799 19.7194 9.31074 19.5143 9 19.4C8.69838 19.2669 8.36381 19.2272 8.03941 19.286C7.71502 19.3448 7.41568 19.4995 7.18 19.73L7.12 19.79C6.93425 19.976 6.71368 20.1235 6.47088 20.2241C6.22808 20.3248 5.96783 20.3766 5.705 20.3766C5.44217 20.3766 5.18192 20.3248 4.93912 20.2241C4.69632 20.1235 4.47575 19.976 4.29 19.79C4.10405 19.6043 3.95653 19.3837 3.85588 19.1409C3.75523 18.8981 3.70343 18.6378 3.70343 18.375C3.70343 18.1122 3.75523 17.8519 3.85588 17.6091C3.95653 17.3663 4.10405 17.1457 4.29 16.96L4.35 16.9C4.58054 16.6643 4.73519 16.365 4.794 16.0406C4.85282 15.7162 4.81312 15.3816 4.68 15.08C4.55324 14.7842 4.34276 14.532 4.07447 14.3543C3.80618 14.1766 3.49179 14.0813 3.17 14.08H3C2.46957 14.08 1.96086 13.8693 1.58579 13.4942C1.21071 13.1191 1 12.6104 1 12.08C1 11.5496 1.21071 11.0409 1.58579 10.6658C1.96086 10.2907 2.46957 10.08 3 10.08H3.09C3.42099 10.0723 3.742 9.96512 4.0113 9.77251C4.28059 9.5799 4.48572 9.31074 4.6 9C4.73312 8.69838 4.77282 8.36381 4.714 8.03941C4.65519 7.71502 4.50054 7.41568 4.27 7.18L4.21 7.12C4.02405 6.93425 3.87653 6.71368 3.77588 6.47088C3.67523 6.22808 3.62343 5.96783 3.62343 5.705C3.62343 5.44217 3.67523 5.18192 3.77588 4.93912C3.87653 4.69632 4.02405 4.47575 4.21 4.29C4.39575 4.10405 4.61632 3.95653 4.85912 3.85588C5.10192 3.75523 5.36217 3.70343 5.625 3.70343C5.88783 3.70343 6.14808 3.75523 6.39088 3.85588C6.63368 3.95653 6.85425 4.10405 7.04 4.29L7.1 4.35C7.33568 4.58054 7.63502 4.73519 7.95941 4.794C8.28381 4.85282 8.61838 4.81312 8.92 4.68H9C9.29577 4.55324 9.54802 4.34276 9.72569 4.07447C9.90337 3.80618 9.99872 3.49179 10 3.17V3C10 2.46957 10.2107 1.96086 10.5858 1.58579C10.9609 1.21071 11.4696 1 12 1C12.5304 1 13.0391 1.21071 13.4142 1.58579C13.7893 1.96086 14 2.46957 14 3V3.09C14.0013 3.41179 14.0966 3.72618 14.2743 3.99447C14.452 4.26276 14.7042 4.47324 15 4.6C15.3016 4.73312 15.6362 4.77282 15.9606 4.714C16.285 4.65519 16.5843 4.50054 16.82 4.27L16.88 4.21C17.0657 4.02405 17.2863 3.87653 17.5291 3.77588C17.7719 3.67523 18.0322 3.62343 18.295 3.62343C18.5578 3.62343 18.8181 3.67523 19.0609 3.77588C19.3037 3.87653 19.5243 4.02405 19.71 4.21C19.896 4.39575 20.0435 4.61632 20.1441 4.85912C20.2448 5.10192 20.2966 5.36217 20.2966 5.625C20.2966 5.88783 20.2448 6.14808 20.1441 6.39088C20.0435 6.63368 19.896 6.85425 19.71 7.04L19.65 7.1C19.4195 7.33568 19.2648 7.63502 19.206 7.95941C19.1472 8.28381 19.1869 8.61838 19.32 8.92V9C19.4468 9.29577 19.6572 9.54802 19.9255 9.72569C20.1938 9.90337 20.5082 9.99872 20.83 10H21C21.5304 10 22.0391 10.2107 22.4142 10.5858C22.7893 10.9609 23 11.4696 23 12C23 12.5304 22.7893 13.0391 22.4142 13.4142C22.0391 13.7893 21.5304 14 21 14H20.91C20.5882 14.0013 20.2738 14.0966 20.0055 14.2743C19.7372 14.452 19.5268 14.7042 19.4 15Z\"\r\n                                            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                            stroke-linejoin=\"round\" />\r\n                                    </g>\r\n                                    <defs>\r\n                                        <clipPath id=\"clip0_1017_22270\">\r\n                                            <rect width=\"24\" height=\"24\" fill=\"currentColor\" />\r\n                                        </clipPath>\r\n                                    </defs>\r\n                                </svg>\r\n\r\n                            </span>\r\n                            <span class=\"menu-title fw-bold \">Store Configuration</span>\r\n                        </span>\r\n                        <!--end::Inbox-->\r\n                    </div>\r\n\r\n                    <!--end::Menu item-->\r\n\r\n\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Draft-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'contact' }\"\r\n                            (click)=\"settingvalue('contact')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path\r\n                                        d=\"M17 21V19C17 17.9391 16.5786 16.9217 15.8284 16.1716C15.0783 15.4214 14.0609 15 13 15H5C3.93913 15 2.92172 15.4214 2.17157 16.1716C1.42143 16.9217 1 17.9391 1 19V21M23 21V19C22.9993 18.1137 22.7044 17.2528 22.1614 16.5523C21.6184 15.8519 20.8581 15.3516 20 15.13M16 3.13C16.8604 3.3503 17.623 3.8507 18.1676 4.55231C18.7122 5.25392 19.0078 6.11683 19.0078 7.005C19.0078 7.89317 18.7122 8.75608 18.1676 9.45769C17.623 10.1593 16.8604 10.6597 16 10.88M13 7C13 9.20914 11.2091 11 9 11C6.79086 11 5 9.20914 5 7C5 4.79086 6.79086 3 9 3C11.2091 3 13 4.79086 13 7Z\"\r\n                                        stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"\r\n                                        stroke-linejoin=\"round\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Contact Details</span>\r\n                        </span>\r\n                        <!--end::Draft-->\r\n                    </div>\r\n                    <!--end::Menu item-->\r\n                    <!--begin::Menu item-->\r\n                    <div class=\"menu-item my-3\">\r\n                        <!--begin::Trash-->\r\n                        <span class=\"menu-link\" [ngClass]=\"{ 'active': select === 'review'}\"\r\n                            (click)=\"settingvalue('review')\">\r\n                            <span class=\"menu-icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"24\" height=\"24\"\r\n                                    viewBox=\"0 0 24 24\" fill=\"none\">\r\n                                    <path fill-rule=\"evenodd\" clip-rule=\"evenodd\"\r\n                                        d=\"M6 1C5.20435 1 4.44129 1.31607 3.87868 1.87868C3.31607 2.44129 3 3.20435 3 4V20C3 20.7957 3.31607 21.5587 3.87868 22.1213C4.44129 22.6839 5.20435 23 6 23H12H18C18.7957 23 19.5587 22.6839 20.1213 22.1213C20.6839 21.5587 21 20.7957 21 20V16.4208L19 18.4208V20C19 20.2652 18.8946 20.5196 18.7071 20.7071C18.5196 20.8946 18.2652 21 18 21H16.4208L15.3286 22.0922L12 23L12.5455 21H6C5.73478 21 5.48043 20.8946 5.29289 20.7071C5.10536 20.5196 5 20.2652 5 20V4C5 3.73478 5.10536 3.48043 5.29289 3.29289C5.48043 3.10536 5.73478 3 6 3H12V9C12 9.55228 12.4477 10 13 10H19V13.5792L21 11.5792V9C21 8.73478 20.8946 8.48043 20.7071 8.29289L13.7071 1.29289C13.5196 1.10536 13.2652 1 13 1H6ZM17.5858 8L14 4.41421V8H17.5858Z\"\r\n                                        fill=\"currentColor\" />\r\n                                    <path\r\n                                        d=\"M20.0779 11.5014C20.2369 11.3424 20.4256 11.2163 20.6333 11.1303C20.8409 11.0443 21.0635 11 21.2883 11C21.5131 11 21.7357 11.0443 21.9434 11.1303C22.151 11.2163 22.3397 11.3424 22.4987 11.5014C22.6576 11.6603 22.7837 11.849 22.8698 12.0567C22.9558 12.2644 23.0001 12.487 23.0001 12.7117C23.0001 12.9365 22.9558 13.1591 22.8698 13.3668C22.7837 13.5745 22.6576 13.7632 22.4987 13.9221L15.3286 22.0923L12 23.0001L12.9078 19.6715L20.0779 11.5014Z\"\r\n                                        stroke=\"currentColor\" stroke-width=\"1.6\" stroke-linecap=\"round\"\r\n                                        stroke-linejoin=\"round\" />\r\n                                </svg></span>\r\n                            <span class=\"menu-title fw-bold \">Review & Submit</span>\r\n                        </span>\r\n                        <!--end::Trash-->\r\n                    </div>\r\n                    <!--end::Menu item-->\r\n\r\n\r\n                </div>\r\n            </div>\r\n            <!--end::Menu-->\r\n        </div>\r\n    </div>\r\n    <div class=\"col-md-9 col-lg-9 col-xl-9 col-xxl-9\">\r\n        <div class=\"card\">\r\n            <div class=\"card-header border-bottom-0\">\r\n                <h1\r\n                    class=\"page-heading d-flex text-dark fw-bold fs-2 flex-column  justify-content-center my-0 sub-head\">\r\n                    <span  *ngIf=\"select === 'store_info'\">Enter Your Store Details</span>\r\n                    <span *ngIf=\"select === 'config'\">Enter Your Store Configuration</span>\r\n                    <span *ngIf=\"select === 'contact'\">Enter Primary SPOC details</span>\r\n                    <span *ngIf=\"select === 'review'\">Review & submit</span>\r\n                </h1>\r\n                <div [hidden]=\"select !== 'contact'\" class=\"card-toolbar\">\r\n                    <button (click)=\"addAltSpoc()\" class=\"btn btn-light-primary1 btn-sm\"><svg class=\"me-2\"\r\n                            xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"14\" viewBox=\"0 0 18 14\" fill=\"none\">\r\n                            <path\r\n                                d=\"M2.7 3.5C2.7 2.57174 3.07928 1.6815 3.75442 1.02513C4.42955 0.368749 5.34522 0 6.3 0C7.25478 0 8.17045 0.368749 8.84558 1.02513C9.52072 1.6815 9.9 2.57174 9.9 3.5C9.9 4.42826 9.52072 5.3185 8.84558 5.97487C8.17045 6.63125 7.25478 7 6.3 7C5.34522 7 4.42955 6.63125 3.75442 5.97487C3.07928 5.3185 2.7 4.42826 2.7 3.5ZM0 13.1879C0 10.4945 2.24437 8.3125 5.01469 8.3125H7.58531C10.3556 8.3125 12.6 10.4945 12.6 13.1879C12.6 13.6363 12.2259 14 11.7647 14H0.835312C0.374063 14 0 13.6363 0 13.1879ZM14.175 8.53125V6.78125H12.375C12.0009 6.78125 11.7 6.48867 11.7 6.125C11.7 5.76133 12.0009 5.46875 12.375 5.46875H14.175V3.71875C14.175 3.35508 14.4759 3.0625 14.85 3.0625C15.2241 3.0625 15.525 3.35508 15.525 3.71875V5.46875H17.325C17.6991 5.46875 18 5.76133 18 6.125C18 6.48867 17.6991 6.78125 17.325 6.78125H15.525V8.53125C15.525 8.89492 15.2241 9.1875 14.85 9.1875C14.4759 9.1875 14.175 8.89492 14.175 8.53125Z\"\r\n                                fill=\"#00A3FF\" />\r\n                        </svg>Add Alternate SPOC</button>\r\n                </div>\r\n            </div>\r\n            <div class=\"card-body pt-1\">\r\n                <form [formGroup]=\"storeForm\">\r\n                    <!-- Store Info Start -->\r\n                    <div [hidden]=\"select !== 'store_info'\">\r\n                        <div class=\"row\">\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeName\" class=\"form-label\">Store Name</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"storeName\" formControlName=\"storeName\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('storeName')?.invalid && storeForm.get('storeName')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('storeName')?.touched && storeForm.get('storeName')?.hasError('required')\">\r\n                                    Store Name is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeCode\" class=\"form-label\">Store Code / Ref Code (optional)</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"storeCode\" formControlName=\"storeCode\">\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"businessType\" class=\"form-label\">Business Type</label>\r\n                                <select class=\"form-select\" id=\"businessType\" formControlName=\"businessType\">\r\n                                    <option value=\"COCO\">COCO</option>\r\n                                    <option value=\"COFO\">COFO</option>\r\n                                    <option value=\"FOFO\">FOFO</option>\r\n                                    <option value=\"FOCO\">FOCO</option>\r\n                                </select>\r\n                            </div>\r\n                            <div class=\"col-md-12 col-lg-6 mb-5\">\r\n                                <label for=\"storeType\" class=\"form-label\">Store Type</label>\r\n                                <select class=\"form-select\" id=\"storeType\" formControlName=\"storeType_type\">\r\n                                    <option value=\"High Street\">High Street</option>\r\n                                    <option value=\"Mall Store\">Mall Store</option>\r\n                                    <option value=\"Kiosk\">Kiosk</option>\r\n                                </select>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\" *ngIf=\"storeForm.get('storeType_type')?.value === 'Mall Store'\">\r\n                                <label for=\"mallName\" class=\"form-label\">Enter Mall Name</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"mallName\" formControlName=\"storeType_name\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('storeType_name')?.invalid && storeForm.get('storeType_name')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('storeType_name')?.touched && storeForm.get('storeType_name')?.hasError('required')\">\r\n                                    Mall Name is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <label for=\"address\" class=\"form-label\">Address Line</label>\r\n                                <input type=\"text\" class=\"form-control\" id=\"address\" formControlName=\"address\" #placesRef=\"ngx-places\" ngx-gp-autocomplete (onAddressChange)=\"handleAddressChange($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('address')?.invalid && storeForm.get('address')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('address')?.touched && storeForm.get('address')?.hasError('required')\">\r\n                                    Address is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"country\" class=\"form-label\">Country</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"country\" formControlName=\"country\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('country')?.invalid && storeForm.get('country')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('country')?.touched && storeForm.get('country')?.hasError('required')\">\r\n                                    Country is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"state\" class=\"form-label\">State</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"state\" formControlName=\"state\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('state')?.invalid && storeForm.get('state')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('state')?.touched && storeForm.get('state')?.hasError('required')\">\r\n                                    State is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"city\" class=\"form-label\">City / Town</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"city\" formControlName=\"city\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('city')?.invalid && storeForm.get('city')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('city')?.touched && storeForm.get('city')?.hasError('required')\">\r\n                                    City is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"pincode\" class=\"form-label\">Pin / Zip Code</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"pincode\" formControlName=\"pincode\" maxlength=\"6\" minlength=\"6\" (keypress)=\"omit_special_char($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('pincode')?.invalid && storeForm.get('pincode')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('pincode')?.touched && storeForm.get('pincode')?.hasError('required')\">\r\n                                    Pincode is required.\r\n                                </small>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"col-12 text-end\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\"\r\n                                    (click)=\"goToConfiguration()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Info End -->\r\n\r\n                    <!-- Store Configuration Start -->\r\n                    <div [hidden]=\"select !== 'config'\">\r\n                        <div class=\"row\">\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"timeZone\" class=\"form-label\">Time Zone</label>\r\n                                <!-- <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"timeZone\" formControlName=\"timeZone\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('timeZone')?.invalid && storeForm.get('timeZone')?.touched}\"> -->\r\n                                    <select class=\"form-select\" id=\"timeZone\" formControlName=\"timeZone\">\r\n                                        <option *ngFor=\"let timezone of timezones\" [value]=\"timezone\">{{ timezone }}</option>\r\n                                    </select>\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('timeZone')?.touched && storeForm.get('timeZone')?.hasError('required')\">\r\n                                    Time Zone is required.\r\n                                </small>\r\n                            </div>\r\n                            <!-- <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"noOfCameras\" class=\"form-label\">No of Cameras</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"noOfCameras\" formControlName=\"cameras\" (keypress)=\"omit_special_char($event)\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('cameras')?.invalid && storeForm.get('cameras')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('cameras')?.touched && storeForm.get('cameras')?.hasError('required')\">\r\n                                    No of Cameras is required.\r\n                                </small>\r\n                            </div> -->\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"storeOpenTime\" class=\"form-label\">Store Open Time</label>\r\n                                <input autocomplete=\"off\" type=\"time\" class=\"form-control\" id=\"storeOpenTime\" formControlName=\"open\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('open')?.invalid && storeForm.get('open')?.touched}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('open')?.touched && storeForm.get('open')?.hasError('required')\">\r\n                                    Store Open Time is required.\r\n                                </small>\r\n                            </div>\r\n                            <div class=\"col-md-6 mb-5\">\r\n                                <label for=\"storeCloseTime\" class=\"form-label\">Store Close Time</label>\r\n                                <input autocomplete=\"off\" type=\"time\" class=\"form-control\" id=\"storeCloseTime\" formControlName=\"close\"\r\n                                    [ngClass]=\"{ 'is-invalid':storeForm.get('close')?.invalid && storeForm.get('close')?.touched || storeForm.hasError('invalidTimeRange')}\">\r\n                                <small class=\"invalid-feedback\"\r\n                                    *ngIf=\"storeForm.get('close')?.touched && storeForm.get('close')?.hasError('required')\">\r\n                                    Store Close Time is required.\r\n                                </small>\r\n                                <small class=\"my-2\" *ngIf=\"storeForm.hasError('invalidTimeRange') && (storeForm.get('open')?.touched || storeForm.get('close')?.touched)\">\r\n                                    Opening time must be before closing time.\r\n                                </small>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row mt-20\">\r\n                            <div class=\"col-12 text-end mt-15\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\" (click)=\"goToContact()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Configuration End -->\r\n\r\n                    <!-- Store Contact Start -->\r\n                    <div [hidden]=\"select !== 'contact'\">\r\n                        <div class=\"row\">\r\n                            <ng-container formArrayName=\"spocDetails\">\r\n                                <ng-container *ngFor=\"let spocDetail of getspocDetailsControls(); let i = index\" [formGroupName]=\"i\">\r\n                                    <div *ngIf=\"i!==0\" class=\"d-flex justify-content-between align-items-center my-6\">\r\n                                        <ng-container >\r\n                                            <span class=\"fw-bold fs-4\">Alternate SPOC {{i}}</span>\r\n                                            <span (click)=\"delAltSpoc()\">\r\n                                                <svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\r\n                                                    <g filter=\"url(#filter0_d_2250_30650)\">\r\n                                                        <rect x=\"2\" y=\"1\" width=\"36\" height=\"36\" rx=\"8\" fill=\"white\" />\r\n                                                        <rect x=\"2.5\" y=\"1.5\" width=\"35\" height=\"35\" rx=\"7.5\" stroke=\"#D0D5DD\" />\r\n                                                        <path\r\n                                                            d=\"M12.5 13.9998H14.1667M14.1667 13.9998H27.5M14.1667 13.9998V25.6665C14.1667 26.1085 14.3423 26.5325 14.6548 26.845C14.9674 27.1576 15.3913 27.3332 15.8333 27.3332H24.1667C24.6087 27.3332 25.0326 27.1576 25.3452 26.845C25.6577 26.5325 25.8333 26.1085 25.8333 25.6665V13.9998H14.1667ZM16.6667 13.9998V12.3332C16.6667 11.8911 16.8423 11.4672 17.1548 11.1547C17.4674 10.8421 17.8913 10.6665 18.3333 10.6665H21.6667C22.1087 10.6665 22.5326 10.8421 22.8452 11.1547C23.1577 11.4672 23.3333 11.8911 23.3333 12.3332V13.9998M18.3333 18.1665V23.1665M21.6667 18.1665V23.1665\"\r\n                                                            stroke=\"#344054\" stroke-width=\"1.67\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                    </g>\r\n                                                    <defs>\r\n                                                        <filter id=\"filter0_d_2250_30650\" x=\"0\" y=\"0\" width=\"40\" height=\"40\"\r\n                                                            filterUnits=\"userSpaceOnUse\" color-interpolation-filters=\"sRGB\">\r\n                                                            <feFlood flood-opacity=\"0\" result=\"BackgroundImageFix\" />\r\n                                                            <feColorMatrix in=\"SourceAlpha\" type=\"matrix\"\r\n                                                                values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0\" result=\"hardAlpha\" />\r\n                                                            <feOffset dy=\"1\" />\r\n                                                            <feGaussianBlur stdDeviation=\"1\" />\r\n                                                            <feColorMatrix type=\"matrix\"\r\n                                                                values=\"0 0 0 0 0.0627451 0 0 0 0 0.0941176 0 0 0 0 0.156863 0 0 0 0.05 0\" />\r\n                                                            <feBlend mode=\"normal\" in2=\"BackgroundImageFix\" result=\"effect1_dropShadow_2250_30650\" />\r\n                                                            <feBlend mode=\"normal\" in=\"SourceGraphic\" in2=\"effect1_dropShadow_2250_30650\"\r\n                                                                result=\"shape\" />\r\n                                                        </filter>\r\n                                                    </defs>\r\n                                                </svg>\r\n                                            </span>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactName\" class=\"form-label\">Name</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"contactName\" formControlName=\"name\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('name')?.invalid && spocDetail.get('name')?.touched}\">\r\n                                        <small class=\"invalid-feedback\"\r\n                                            *ngIf=\"spocDetail.get('name')?.touched && spocDetail.get('name')?.hasError('required')\">\r\n                                            Name is required.\r\n                                        </small>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactEmail\" class=\"form-label\">Email</label>\r\n                                        <input autocomplete=\"off\" type=\"email\" class=\"form-control\" id=\"contactEmail\" formControlName=\"email\"\r\n                                            pattern=\"^([a-zA-Z0-9_\\-\\.]+)@[a-z0-9-]+(\\.[a-z0-9-]+)*(\\.[a-zA-Z]{2,3})$\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('email')?.invalid && spocDetail.get('email')?.touched}\">\r\n                                        <ng-container *ngIf=\"spocDetail.get('email')?.touched\">\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('required')\">\r\n                                                Email is required.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('minlength')\">\r\n                                                Email must be at least 3 characters long.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('email')?.hasError('maxlength')\">\r\n                                                Email must be not more than 100 characters long.\r\n                                            </small>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"contactNumber\" class=\"form-label\">Contact Number</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"contactNumber\" minlength=\"10\" maxlength=\"13\"\r\n                                            (keypress)=\"omit_special_char($event)\" formControlName=\"contact\"\r\n                                            [ngClass]=\"{ 'is-invalid':spocDetail.get('contact')?.invalid && spocDetail.get('contact')?.touched}\">\r\n                                        <ng-container *ngIf=\"spocDetail.get('contact')?.touched\">\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('required')\">\r\n                                                Contact is required.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('minlength')\">\r\n                                                Contact must be at least 10 digits.\r\n                                            </small>\r\n                                            <small class=\"invalid-feedback\" *ngIf=\"spocDetail.get('contact')?.hasError('maxlength')\">\r\n                                                Contact must be not more than 13 digits.\r\n                                            </small>\r\n                                        </ng-container>\r\n                                    </div>\r\n                                    <div class=\"col-md-6 mb-5\">\r\n                                        <label for=\"designation\" class=\"form-label\">Designation (optional)</label>\r\n                                        <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"designation\" formControlName=\"designation\">\r\n                                    </div>\r\n                                </ng-container>\r\n                            </ng-container>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <h1 class=\"sub-head\">Enter Store Connection Details</h1>\r\n                            </div>\r\n                            <div class=\"col-md-12 mb-5\">\r\n                                <label for=\"anyDeskID\" class=\"form-label\">AnyDesk ID / TeamViewer ID (optional)</label>\r\n                                <input autocomplete=\"off\" type=\"text\" class=\"form-control\" id=\"anyDeskID\"\r\n                                    formControlName=\"storeConnectionId\">\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"col-12 text-end\">\r\n                                <button type=\"button\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\" (click)=\"navigateToAddStore()\">Cancel</button>\r\n                                <button type=\"button\" class=\"btn btn-primary\" (click)=\"goToReview()\">Next</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Store Contact End -->\r\n\r\n                    <!-- Review & Submit Start -->\r\n                    <div [hidden]=\"select !== 'review'\">\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Store\r\n                            Info\r\n                        </div>\r\n                        <div class=\"card-body p-9\">\r\n\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Name</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('storeName')?.value ?\r\n                                        storeForm.get('storeName')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Code</label>\r\n                                <div class=\"col-lg-9 fv-row\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val\">{{storeForm.get('storeCode')?.value ?\r\n                                        storeForm.get('storeCode')?.value: 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                                                           \r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Business Type</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val text-hover-primary\">\r\n                                        {{storeForm.get('businessType')?.value ? storeForm.get('businessType')?.value :\r\n                                        'NA'}} </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Type\r\n                                    <!-- <i data-bs-toggle=\"tooltip\"\r\n                                        title=\"Phone number must be active\" class=\"fas fa-exclamation-circle ms-1 fs-7\"></i> -->\r\n                                </label>\r\n                                <div class=\"col-lg-9 d-flex align-items-center\">\r\n                                    <span\r\n                                        class=\"fw-bolder fs-6 me-2 text-review-val\">{{storeForm.get('storeType_type')?.value\r\n                                        ? storeForm.get('storeType_type')?.value : 'NA'}}</span>\r\n                                    <!-- <span class=\"badge badge-success\">Verified</span> -->\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\"\r\n                                *ngIf=\"storeForm.get('storeType_type')?.value && storeForm.get('storeType_type')?.value === 'Mall Store'\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\"> Mall Name</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('storeType_name')?.value\r\n                                        ? storeForm.get('storeType_name')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Address</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">\r\n                                        <ng-container>\r\n                                            {{storeForm.get('address')?.value ? storeForm.get('address')?.value : 'NA'}}\r\n                                        </ng-container>\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <!-- <div class=\"row mb-10\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Allow Changes</label>\r\n                                <div class=\"col-lg-9\"><span class=\"fw-bold fs-6\">Yes</span></div>\r\n                            </div> -->\r\n\r\n                        </div>\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Store\r\n                            Configuration</div>\r\n                        <div class=\"card-body p-9\">\r\n\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Time Zone</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('timeZone')?.value ?\r\n                                        storeForm.get('timeZone')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n                            <!-- <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">No of Cameras</label>\r\n                                <div class=\"col-lg-9 fv-row\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val\">{{storeForm.get('cameras')?.value ?\r\n                                        storeForm.get('cameras')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div> -->\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Open Time</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bold fs-6 text-review-val text-hover-primary\">{{storeForm.get('open')?.value\r\n                                        ? storeForm.get('open')?.value : 'NA'}}\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"row mb-7\">\r\n                                <label class=\"col-lg-3 fw-bold text-muted-review\">Store Close Time</label>\r\n                                <div class=\"col-lg-9\"><span\r\n                                        class=\"fw-bolder fs-6 text-review-val\">{{storeForm.get('close')?.value ?\r\n                                        storeForm.get('close')?.value : 'NA'}}</span>\r\n                                </div>\r\n                            </div>\r\n\r\n                        </div>\r\n                        <div class=\"fs-4 fw-bold text-hover-primary sub-title text-gray-600 m-0 cursor-pointer\">Contact\r\n                            Details</div>\r\n                        <div class=\"card-body row px-9 pt-3 pb-4\">\r\n                            <div class=\"table-responsive col-md-12 col-lg-12 col-xl-9 col-xxl-8\">\r\n                                <table class=\"table align-middle gy-6\">\r\n                                    <tbody class=\"fs-6 fw-bold\"> \r\n                                        <ng-container formArrayName=\"spocDetails\">\r\n                                            <ng-container *ngFor=\"let spoc of getspocDetailsControls();let i=index;\">\r\n                                                <tr>\r\n                                                    <td>Spoc {{i+1}}</td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <path\r\n                                                                d=\"M15 15.75V14.25C15 13.4544 14.6839 12.6913 14.1213 12.1287C13.5587 11.5661 12.7956 11.25 12 11.25H6C5.20435 11.25 4.44129 11.5661 3.87868 12.1287C3.31607 12.6913 3 13.4544 3 14.25V15.75M12 5.25C12 6.90685 10.6569 8.25 9 8.25C7.34315 8.25 6 6.90685 6 5.25C6 3.59315 7.34315 2.25 9 2.25C10.6569 2.25 12 3.59315 12 5.25Z\"\r\n                                                                stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.name ?\r\n                                                            getspocDetailsValues(i)?.name : 'NA' }}</span></td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <g clip-path=\"url(#clip0_1_80373)\">\r\n                                                                <path\r\n                                                                    d=\"M12 6.00002V9.75002C12 10.3468 12.2371 10.9191 12.659 11.341C13.081 11.763 13.6533 12 14.25 12C14.8467 12 15.419 11.763 15.841 11.341C16.263 10.9191 16.5 10.3468 16.5 9.75002V9.00002C16.4999 7.30729 15.9272 5.66438 14.875 4.33842C13.8227 3.01246 12.3529 2.08144 10.7045 1.69675C9.05605 1.31205 7.32596 1.4963 5.79552 2.21955C4.26508 2.94279 3.02431 4.16249 2.27495 5.68032C1.5256 7.19814 1.31173 8.92483 1.66813 10.5796C2.02453 12.2344 2.93024 13.7199 4.23798 14.7947C5.54572 15.8695 7.17858 16.4703 8.87106 16.4994C10.5635 16.5285 12.2161 15.9842 13.56 14.955M12 9.00002C12 10.6569 10.6569 12 9.00001 12C7.34315 12 6.00001 10.6569 6.00001 9.00002C6.00001 7.34317 7.34315 6.00002 9.00001 6.00002C10.6569 6.00002 12 7.34317 12 9.00002Z\"\r\n                                                                    stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                            </g>\r\n                                                            <defs>\r\n                                                                <clipPath id=\"clip0_1_80373\">\r\n                                                                    <rect width=\"18\" height=\"18\" fill=\"white\" />\r\n                                                                </clipPath>\r\n                                                            </defs>\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.email ?\r\n                                                            getspocDetailsValues(i)?.email : 'NA' }}</span></td>\r\n                                                    <td><svg xmlns=\"http://www.w3.org/2000/svg\" width=\"18\" height=\"18\" viewBox=\"0 0 18 18\" fill=\"none\">\r\n                                                            <g clip-path=\"url(#clip0_1_80376)\">\r\n                                                                <path\r\n                                                                    d=\"M16.5001 12.6901V14.9401C16.5009 15.1489 16.4581 15.3557 16.3745 15.5471C16.2908 15.7385 16.168 15.9103 16.0141 16.0515C15.8602 16.1927 15.6785 16.3002 15.4806 16.3671C15.2828 16.434 15.0731 16.4589 14.8651 16.4401C12.5572 16.1893 10.3403 15.4007 8.39257 14.1376C6.58044 12.9861 5.04407 11.4497 3.89257 9.63757C2.62506 7.68098 1.83625 5.45332 1.59007 3.13507C1.57133 2.92767 1.59598 2.71864 1.66245 2.52129C1.72892 2.32394 1.83575 2.14259 1.97615 1.98879C2.11654 1.83499 2.28743 1.7121 2.47792 1.62796C2.6684 1.54382 2.87433 1.50027 3.08257 1.50007H5.33257C5.69655 1.49649 6.04942 1.62538 6.32539 1.86272C6.60137 2.10006 6.78163 2.42966 6.83257 2.79007C6.92754 3.51012 7.10366 4.21712 7.35757 4.89757C7.45848 5.16602 7.48032 5.45776 7.4205 5.73823C7.36069 6.01871 7.22172 6.27616 7.02007 6.48007L6.06757 7.43257C7.13524 9.31023 8.68991 10.8649 10.5676 11.9326L11.5201 10.9801C11.724 10.7784 11.9814 10.6395 12.2619 10.5796C12.5424 10.5198 12.8341 10.5417 13.1026 10.6426C13.783 10.8965 14.49 11.0726 15.2101 11.1676C15.5744 11.219 15.9071 11.4025 16.145 11.6832C16.3828 11.9639 16.5092 12.3223 16.5001 12.6901Z\"\r\n                                                                    stroke=\"#667085\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\r\n                                                            </g>\r\n                                                            <defs>\r\n                                                                <clipPath id=\"clip0_1_80376\">\r\n                                                                    <rect width=\"18\" height=\"18\" fill=\"white\" />\r\n                                                                </clipPath>\r\n                                                            </defs>\r\n                                                        </svg><span class=\"ms-2\">{{getspocDetailsValues(i)?.contact ?\r\n                                                            getspocDetailsValues(i)?.contact : 'NA' }}</span></td>\r\n                                                </tr>\r\n                                            </ng-container>\r\n                                        </ng-container>\r\n                                        <tr>\r\n                                            <td>AnyDesk ID\r\n                                            <td>\r\n                                                <span class=\"ms-2\">{{storeForm.get('storeConnectionId')?.value ?\r\n                                                    storeForm.get('storeConnectionId')?.value : 'NA' }}</span>\r\n                                            </td>\r\n                                        </tr>\r\n                                    </tbody>\r\n                                </table>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"row\">\r\n                            <div class=\"text-end\">\r\n                                <button type=\"button\" (click)=\"goToStoreInfo()\"\r\n                                    class=\"btn btn-default mx-3 btn-outline btn-outline-default rounded-3\">Edit</button>\r\n                                <button type=\"button\" [disabled]=\"storeForm.invalid\" (click)=\"onSubmit()\"\r\n                                    class=\"btn btn-primary\">Submit</button>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                    <!-- Review & Submit End -->\r\n                </form>\r\n            </div>\r\n        </div>\r\n    </div>\r\n</div>"]}

package/esm2022/lib/services/stores.service.mjs

@@ -40,12 +40,12 @@ export class StoresService {
     createStore(storeBody) {
         return this.http
             .post(`${this.storeApiUrl}/create-store`, storeBody)
-            .pipe(map((response) => response), catchError(this.handleError));
+            .pipe(map((response) => response));
     }
     updateStore(storeId, storesBodyReq) {
         return this.http
             .put(`${this.storeApiUrl}/update-store/${storeId}`, storesBodyReq)
-            .pipe(map((response) => response), catchError(this.handleError));
+            .pipe(map((response) => response));
     }
     storeBulkUpload(storesBodyReq) {
         return this.http
@@ -108,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImpor
                     providedIn: "root",
                 }]
         }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.GlobalStateService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stores.service.js","sourceRoot":"","sources":["../../../../../projects/tango-manage-stores/src/lib/services/stores.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { HttpClient, HttpErrorResponse } from \"@angular/common/http\";\r\nimport { Observable, catchError, map, throwError } from \"rxjs\";\r\nimport { Store, StoreResponse } from \"../interfaces/store.interface\";\r\nimport { GlobalStateService } from \"tango-app-ui-global\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class StoresService {\r\n  private storeApiUrl = \"\";\r\n  // private userInfraApiUrl = \"\";\r\n  private middlewareApiUrl = \"\";\r\n  private ticketsApiUrl = \"\";  \r\n  constructor(private http: HttpClient, private gs: GlobalStateService) {\r\n    this.gs.environment.subscribe((env) => {\r\n      if (env) {\r\n        this.storeApiUrl = env.storeApiUrl;\r\n        // this.userInfraApiUrl = env.userInfraApiUrl;\r\n        this.middlewareApiUrl = env.middlewareApiUrl;\r\n        this.ticketsApiUrl = env.ticketsApiUrl;\r\n      }\r\n    });\r\n  }\r\n\r\n  getStoreList(req: any): Observable<any> {\r\n    return this.http\r\n      .post<any>(`${this.storeApiUrl}/storeInfraList`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStoreListExport(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.storeApiUrl}/storeInfraList`, req, {\r\n        responseType: \"arraybuffer\",\r\n      })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStore(storeId: string): Observable<any> {\r\n    return this.http.get<any>(`${this.storeApiUrl}/get-store/${storeId}`).pipe(\r\n      map((response: any) => response),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  createStore(storeBody: StoreResponse): Observable<Store> {\r\n    return this.http\r\n      .post<Store>(`${this.storeApiUrl}/create-store`, storeBody)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n  \r\n  updateStore(storeId:string,storesBodyReq: any): Observable<any> {\r\n    return this.http\r\n      .put<any>(`${this.storeApiUrl}/update-store/${storeId}`, storesBodyReq)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  storeBulkUpload(storesBodyReq: any): Observable<any> {\r\n    return this.http\r\n      .post<any>(`${this.storeApiUrl}/storeBulkUpload`, storesBodyReq)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getCountries(params?: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-countries`, { params: params })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStates(params: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-country-states`, {\r\n        params: params,\r\n      })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getCities(params: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-state-cities`, { params: params })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getAddress(latitude: number, longitude: number) {\r\n    return fetch(\r\n      `https://maps.googleapis.com/maps/api/geocode/json?latlng=${latitude},${longitude}&key=AIzaSyDlOezgwQO0JviD0aizrCuN1FY9tcWfR3o`\r\n    )\r\n      .then((res) => {\r\n        if (!res.ok) {\r\n          throw new Error(\"Network response was not ok\");\r\n        }\r\n        return res.json();\r\n      })\r\n      .then((data) => {\r\n        if (data.status === \"OK\") {\r\n          return data.results[0];\r\n        } else {\r\n          throw new Error(data.status);\r\n        }\r\n      });\r\n  }\r\n\r\n  createInfraTicket(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.ticketsApiUrl}/infra/createTicket`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  bulkInfraTicket(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.ticketsApiUrl}/infra/bulkcreateTicket`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  private handleError(error: HttpErrorResponse): Observable<never> {\r\n    return throwError(\r\n      () => new Error(\"Something bad happened; please try again later\")\r\n    );\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stores.service.js","sourceRoot":"","sources":["../../../../../projects/tango-manage-stores/src/lib/services/stores.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { HttpClient, HttpErrorResponse } from \"@angular/common/http\";\r\nimport { Observable, catchError, map, throwError } from \"rxjs\";\r\nimport { Store, StoreResponse } from \"../interfaces/store.interface\";\r\nimport { GlobalStateService } from \"tango-app-ui-global\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class StoresService {\r\n  private storeApiUrl = \"\";\r\n  // private userInfraApiUrl = \"\";\r\n  private middlewareApiUrl = \"\";\r\n  private ticketsApiUrl = \"\";  \r\n  constructor(private http: HttpClient, private gs: GlobalStateService) {\r\n    this.gs.environment.subscribe((env) => {\r\n      if (env) {\r\n        this.storeApiUrl = env.storeApiUrl;\r\n        // this.userInfraApiUrl = env.userInfraApiUrl;\r\n        this.middlewareApiUrl = env.middlewareApiUrl;\r\n        this.ticketsApiUrl = env.ticketsApiUrl;\r\n      }\r\n    });\r\n  }\r\n\r\n  getStoreList(req: any): Observable<any> {\r\n    return this.http\r\n      .post<any>(`${this.storeApiUrl}/storeInfraList`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStoreListExport(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.storeApiUrl}/storeInfraList`, req, {\r\n        responseType: \"arraybuffer\",\r\n      })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStore(storeId: string): Observable<any> {\r\n    return this.http.get<any>(`${this.storeApiUrl}/get-store/${storeId}`).pipe(\r\n      map((response: any) => response),\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  createStore(storeBody: StoreResponse): Observable<Store> {\r\n    return this.http\r\n      .post<Store>(`${this.storeApiUrl}/create-store`, storeBody)\r\n      .pipe(\r\n        map((response: any) => response)\r\n       \r\n      );\r\n  }\r\n  \r\n  updateStore(storeId:string,storesBodyReq: any): Observable<any> {\r\n    return this.http\r\n      .put<any>(`${this.storeApiUrl}/update-store/${storeId}`, storesBodyReq)\r\n      .pipe(\r\n        map((response: any) => response)\r\n      );\r\n  }\r\n\r\n  storeBulkUpload(storesBodyReq: any): Observable<any> {\r\n    return this.http\r\n      .post<any>(`${this.storeApiUrl}/storeBulkUpload`, storesBodyReq)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getCountries(params?: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-countries`, { params: params })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getStates(params: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-country-states`, {\r\n        params: params,\r\n      })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getCities(params: any): Observable<any> {\r\n    return this.http\r\n      .get<any>(`${this.middlewareApiUrl}/get-state-cities`, { params: params })\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  getAddress(latitude: number, longitude: number) {\r\n    return fetch(\r\n      `https://maps.googleapis.com/maps/api/geocode/json?latlng=${latitude},${longitude}&key=AIzaSyDlOezgwQO0JviD0aizrCuN1FY9tcWfR3o`\r\n    )\r\n      .then((res) => {\r\n        if (!res.ok) {\r\n          throw new Error(\"Network response was not ok\");\r\n        }\r\n        return res.json();\r\n      })\r\n      .then((data) => {\r\n        if (data.status === \"OK\") {\r\n          return data.results[0];\r\n        } else {\r\n          throw new Error(data.status);\r\n        }\r\n      });\r\n  }\r\n\r\n  createInfraTicket(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.ticketsApiUrl}/infra/createTicket`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  bulkInfraTicket(req: any): Observable<any> {\r\n    return this.http\r\n      .post(`${this.ticketsApiUrl}/infra/bulkcreateTicket`, req)\r\n      .pipe(\r\n        map((response: any) => response),\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  private handleError(error: HttpErrorResponse): Observable<never> {\r\n    return throwError(\r\n      () => new Error(\"Something bad happened; please try again later\")\r\n    );\r\n  }\r\n}\r\n"]}