simpo-component-library 3.6.740 → 3.6.742

package/esm2022/lib/ecommerce/sections/cart/cart.component.mjs

@@ -413,8 +413,22 @@ export class CartComponent extends BaseSection {
             this.router.navigate(['/login'], { queryParams: { cart: true } });
         }
     }
+    toSlug(input) {
+        if (!input)
+            return null;
+        const noWhitespace = input.replace(/\s+/g, '-');
+        const normalized = noWhitespace.normalize('NFD');
+        const slug = normalized.replace(/[^\w-]/g, '');
+        return slug
+            .toLowerCase()
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+    }
     goToProductDetails(product) {
-        this.router.navigate(['/details'], { queryParams: { id: product.itemId, varientId: product.varientId } });
+        const slug = product.slugifiedName || this.toSlug(product.itemName);
+        if (!slug)
+            return;
+        this.router.navigate(['/details', slug]);
     }
     proceedToListPage() {
         this.router.navigate(['/']);
@@ -626,6 +640,27 @@ export class CartComponent extends BaseSection {
                     showCloseButton: true
                 }).then(async (response) => {
                     this.currentTab = "BAG";
+                    this.messageService.add({ severity: 'info', summary: 'Processing', detail: 'Please wait, updaing your cart', life: 2000 });
+                    const regExp = /{([^}]+)}/g;
+                    const id = regExp.exec(error.message)?.[1];
+                    let itemDetail = null;
+                    const productDetailsAsync = await this.restService.getProductDetails(id).toPromise().then((response) => {
+                        itemDetail = response[0];
+                    });
+                    if (response.isDismissed) {
+                        this.cartInfo.orderedItems.forEach((item) => {
+                            if (item.itemId == itemDetail?.itemId)
+                                item.quantity = itemDetail?.itemInventory.openingStock;
+                        });
+                        const addItemDBAsync = await this.restService.addItemToDB(this.cartInfo).toPromise();
+                        const addItemIndexDBAsync = await this.storageService.addAllProductsToCart(this.cartInfo.orderedItems);
+                    }
+                    else if (response.isConfirmed) {
+                        this.cartInfo.orderedItems = this.cartInfo.orderedItems.filter((item) => item.itemId != itemDetail?.itemId);
+                        const addItemDBAsync = await this.restService.addItemToDB(this.cartInfo).toPromise();
+                        const addItemIndexDBAsync = await this.storageService.addAllProductsToCart(this.cartInfo.orderedItems);
+                        this.proceedToPayment();
+                    }
                 });
             }
             else {
@@ -1089,4 +1124,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: ViewChild,
                 args: ['d2']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cart.component.js","sourceRoot":"","sources":["../../../../../../../projects/simpo-ui/src/lib/ecommerce/sections/cart/cart.component.ts","../../../../../../../projects/simpo-ui/src/lib/ecommerce/sections/cart/cart.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, Inject, Input, OnDestroy, OnInit, Optional, TemplateRef, ViewChild } from '@angular/core';\r\nimport { Address, CartSectionModal, CartSectionStylesModel } from './cart.modal';\r\nimport { ToastModule } from 'primeng/toast';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { CommonModule } from '@angular/common';\r\nimport { ButtonDirectiveDirective } from '../../../directive/button-directive.directive';\r\nimport { MatIcon, MatIconModule } from '@angular/material/icon';\r\nimport { AnimationDirective } from '../../../directive/animation-directive';\r\nimport { HoverDirective } from '../../../directive/hover-element-directive';\r\nimport { ContentFitDirective } from '../../../directive/content-fit-directive';\r\nimport { SimpoComponentModule } from '../../../components/index';\r\nimport BaseSection from '../../../sections/BaseSection';\r\nimport { EventsService } from '.././../../services/events.service';\r\nimport { CartService } from '../../../services/cart.service';\r\nimport { AddressComponent } from \"../address/address.component\";\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { AuthenticateUserComponent } from '../authenticate-user/authenticate-user.component';\r\nimport { MAT_DIALOG_DATA, MatDialog, MatDialogModule, MatDialogRef } from '@angular/material/dialog';\r\nimport { RestService } from \"../../../services/rest.service\";\r\nimport { StorageServiceService } from '../../../services/storage.service';\r\nimport { AddressDetails, User } from '../../styles/user.modal';\r\nimport { OrderedItems } from '../../styles/OrderedItems.modal';\r\nimport { BUSINESS_CONSTANTS } from '../../../constants/business.constant';\r\nimport { MessageService } from 'primeng/api';\r\nimport Swal from 'sweetalert2';\r\nimport { BackgroundDirective } from '../../../directive/background-directive';\r\nimport { MatBottomSheet, MatBottomSheetModule } from '@angular/material/bottom-sheet';\r\nimport { checkItemAlreadyAdded, Product, syncItemToServerDBRequest } from '../../styles/product.modal';\r\nimport { CustomerReviewComponent } from '../customer-review/customer-review.component';\r\nimport { merge, Subscription } from 'rxjs';\r\nimport { response } from 'express';\r\nimport { TextEditorComponent } from '../../../elements/text-editor/text-editor.component';\r\nimport { ImageEditorDirective } from '../../../directive/image-editor.directive';\r\nimport { LayOutModel } from '../../../styles/style.model';\r\nimport { SpacingHorizontalDirective } from '../../../directive/spacing-horizontal.directive';\r\nimport { AddressListComponent } from '../../../elements/address-list/address-list.component';\r\nimport { ScheduleVideoCallComponent } from '../../../elements/schedule-video-call/schedule-video-call.component';\r\nimport { ButtonEditorDirective } from '../../../directive/button-editor.directive';\r\nimport { SchemeSelectionComponent } from '../scheme-selection/scheme-selection.component';\r\nimport { ColorDirective } from '../../../directive/color.directive';\r\nimport { Unary } from '@angular/compiler';\r\nimport { MatSpinner } from '@angular/material/progress-spinner';\r\n\r\ninterface Coupon {\r\n  discountType: string;\r\n  discountName: string;\r\n  discountDescription: string;\r\n  applicable: boolean;\r\n  couponCode: string;\r\n  couponId: string;\r\n  status: boolean;\r\n  validFrom: Date;\r\n  validTo: Date;\r\n}\r\n\r\n@Component({\r\n  selector: 'simpo-cart',\r\n  standalone: true,\r\n  imports: [\r\n    FormsModule,\r\n    CommonModule,\r\n    MatIcon,\r\n    MatDialogModule,\r\n    SimpoComponentModule,\r\n    BackgroundDirective,\r\n    MatBottomSheetModule,\r\n    //DIRECTIVE\r\n    ButtonDirectiveDirective,\r\n    AnimationDirective,\r\n    ContentFitDirective,\r\n    HoverDirective,\r\n    AddressComponent,\r\n    ToastModule,\r\n    TextEditorComponent,\r\n    ImageEditorDirective,\r\n    SpacingHorizontalDirective,\r\n    AddressListComponent,\r\n    MatIconModule,\r\n    ButtonEditorDirective,\r\n    ColorDirective,\r\n    MatSpinner\r\n  ],\r\n  providers: [MessageService],\r\n  templateUrl: './cart.component.html',\r\n  styleUrl: './cart.component.css'\r\n})\r\nexport class CartComponent extends BaseSection implements OnInit, OnDestroy {\r\n  @Input() data?: CartSectionModal;\r\n  @Input() responseData?: any;\r\n  @Input() index?: number;\r\n  @Input() edit?: boolean;\r\n  @Input() delete?: boolean;\r\n  @Input() customClass?: string;\r\n  isLoading: boolean = false;\r\n\r\n  styles?: CartSectionStylesModel;\r\n  public currentTab: 'BAG' | 'ADDRESS' | 'PAYMENT' = \"BAG\";\r\n  cartType: 'SHOPPING' | 'TRIAL' = \"SHOPPING\"\r\n  @ViewChild('d2') d2!: ElementRef;\r\n\r\n  pincode: any;\r\n  constructor(\r\n    private readonly _eventService: EventsService,\r\n    private readonly cartService: CartService,\r\n    private readonly router: Router,\r\n    private readonly restService: RestService,\r\n    private readonly matDialog: MatDialog,\r\n    private readonly storageService: StorageServiceService,\r\n    private readonly messageService: MessageService,\r\n    private readonly bottomSheet: MatBottomSheet,\r\n    private readonly activatedRoute: ActivatedRoute,\r\n    @Optional() @Inject(MAT_DIALOG_DATA) public matDialogData: any,\r\n    @Optional() public dialogRef: MatDialogRef<CartComponent>\r\n  ) {\r\n    super();\r\n    this.pincode = localStorage.getItem('pincode');\r\n  }\r\n\r\n  quantity = [1, 2, 3, 4, 5, 6]\r\n  private userDetails: User | null = null;\r\n  private USER_CART_ITEMS: OrderedItems[] | null = null;\r\n  public selectedAddressIdx: number = 0;\r\n  public defaultAddress?: AddressDetails;\r\n  public enteredCouponCode: string = \"\";\r\n  public couponList: Coupon[] = [];\r\n  trialCartItem: OrderedItems[] | null = null\r\n  selectMatureScheme: boolean = false;\r\n  cartInfo: any = {\r\n    orderedItems: null,\r\n    businessId: localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\"),\r\n    billdetails: {\r\n      \"totalNetValue\": 0,\r\n      \"totalTaxAfterDiscount\": 0,\r\n      \"totalGrossValue\": 0,\r\n      \"totalTax\": 0,\r\n      \"totalOfferedValue\": 0,\r\n      \"discountAmount\": 0,\r\n      \"deliveryCharges\": 0,\r\n      \"orraSchemeRedeemedAmount\": 0,\r\n      \"orraSchemeCode\": \"\"\r\n    },\r\n    platform: \"WEB\",\r\n    cartType: \"CART\",\r\n    addressDetails: null,\r\n    userDetails: {\r\n      \"userId\": \"\",\r\n      \"userName\": \"\",\r\n      \"mobile\": \"\",\r\n      \"email\": \"\"\r\n    },\r\n    totalAmount: 0\r\n  }\r\n\r\n  loadingSubscription?: Subscription;\r\n  subIndustryName: string = ''\r\n  isJewellery: boolean = false;\r\n  selectedRedemption: boolean = false;\r\n  ecomConfigs: any;\r\n\r\n  ngOnInit() {\r\n    this.checkAppInstalled()\r\n    this.subIndustryName = localStorage.getItem('subIndustryName') ?? \"\";\r\n    if (this.subIndustryName != null) {\r\n      this.isJewellery = this.subIndustryName == 'Ecommerce Jewellery' ? true : false;\r\n    }\r\n    this.activatedRoute.queryParams.subscribe((param: any) => {\r\n      if (param && param['checkout'])\r\n        this.currentTab = \"ADDRESS\";\r\n    })\r\n    this._eventService.showDummyCartItems.subscribe((response: boolean) => {\r\n      this.responseData = this.styles?.cartItemsStyling && this.edit ? this.dummyCartItems : this.edit ? undefined : this.responseData;\r\n    })\r\n    this.getTrialCart();\r\n    this.getIndexDBData();\r\n    this.getSchemeDetails();\r\n    this.getEcommerceConfigs();\r\n    this.styles = this.data?.styles;\r\n    // console.log(this.data)\r\n  }\r\n  dummyCartItems: any = {\r\n    \"cartId\": \"1f0dd796-b9d8-6c1f-8d3b-d7330cc27a9f\",\r\n    \"businessId\": \"1f0dca42-fe4e-606c-ae3b-e94230be5cd2\",\r\n    \"pgOrderId\": null,\r\n    \"orderedItems\": [\r\n      {\r\n        \"itemId\": \"1efb5ff2-3df3-6dca-ae25-b910d9b2006f\",\r\n        \"varientId\": \"1efb5ff2-3df3-6dca-ae25-b910d9b2006f\",\r\n        \"businessId\": \"1efb3bdc-fd68-65d0-9039-6dac09c61303\",\r\n        \"itemName\": \"XXXXXXXXXXXX\",\r\n        \"businessName\": null,\r\n        \"imgUrl\": \"https://i.postimg.cc/hPS2JpV0/no-image-available.jpg\",\r\n        \"itemVariant\": null,\r\n        \"taxCategory\": null,\r\n        \"quantity\": 1,\r\n        \"price\": 22000.0,\r\n        \"itemTax\": 0.0,\r\n        \"discountedPrice\": 22000.0,\r\n        \"discountAmount\": 0.0,\r\n        \"taxAfterDiscount\": 0.0,\r\n        \"sellingPrice\": 22000.0,\r\n        \"value\": 0.0,\r\n        \"rating\": 0,\r\n        \"review\": null,\r\n        \"reviewImages\": null\r\n      },\r\n    ],\r\n    \"billdetails\": {\r\n      \"totalNetValue\": 27000.0,\r\n      \"totalGrossValue\": 27250.0,\r\n      \"totalTax\": 250.0,\r\n      \"finalPrice\": 27250.0,\r\n      \"taxBreakup\": {\r\n        \"cgstValue\": 125.0,\r\n        \"sgstValue\": 125.0,\r\n        \"igstValue\": 0.0\r\n      },\r\n      \"deliveryCharges\": 0.0,\r\n      \"couponId\": null,\r\n      \"couponCode\": null,\r\n      \"discountAmount\": 0.0,\r\n      \"totalTaxAfterDiscount\": 0.0,\r\n      \"orraSchemeCode\": null,\r\n      \"orraSchemeRedeemedAmount\": 0.0\r\n    },\r\n    \"platform\": \"WEB\",\r\n    \"addressDetails\": null,\r\n    \"userDetails\": {\r\n      \"userId\": \"87896c32-41af-497d-a8df-134b368ee1b2\",\r\n      \"userName\": \"jothisha\",\r\n      \"mobile\": \"9381471527\",\r\n      \"email\": \"jothisha@tejsoft.com\"\r\n    },\r\n    \"createdTimeStamp\": \"2025-12-20T07:57:43.180+00:00\",\r\n    \"totalAmount\": 27250.0,\r\n    \"cartType\": \"CART\"\r\n  }\r\n  getEcommerceConfigs() {\r\n    this.restService.getEcommerceConfigs().subscribe((res: any) => {\r\n      this.ecomConfigs = res?.data\r\n    })\r\n  }\r\n\r\n  schemeList: any[] = []\r\n  getSchemeDetails() {\r\n    this.restService.getAllOrraScheme().subscribe((res: any) => {\r\n      this.schemeList = [res.data];\r\n    })\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.loadingSubscription?.unsubscribe();\r\n  }\r\n  onToggleChange() {\r\n\r\n    if (!this.userDetails) {\r\n      this.selectMatureScheme = false;\r\n      this.messageService.add({ severity: 'error', summary: 'Scheme', detail: 'Login First to redeem' });\r\n      this.router.navigate(['/login'])\r\n      return;\r\n    }\r\n    this.selectMatureScheme = !this.selectMatureScheme;\r\n    if (!this.selectMatureScheme)\r\n      this.showReedemError = false\r\n    if (!this.selectMatureScheme && this.cartInfo.billdetails.orraSchemeCode) {\r\n      let request: any = { \"amount\": this.cartInfo.billdetails.orraSchemeRedeemedAmount, \"GPPId\": this.cartInfo.billdetails.orraSchemeCode }\r\n      this.redeemScheme(request, true)\r\n    }\r\n  }\r\n  getTrialCart() {\r\n    let user: User | null = this.storageService.getUser()\r\n    if (user) {\r\n      this.restService.getUserItems(user.userId, 'TRIAL_CART').subscribe((res: any) => {\r\n        this.trialCartItem = res?.data?.[0]?.orderedItems ?? []\r\n      })\r\n    } else {\r\n      this.getTrialCartIndexDBData();\r\n    }\r\n  }\r\n\r\n  getTrialCartIndexDBData() {\r\n    this.storageService.getTrialCart().then((response) => {\r\n      response.onsuccess = (userTrialCartResponse: any) => {\r\n        this.trialCartItem = userTrialCartResponse.target.result;\r\n      }\r\n    })\r\n  }\r\n\r\n  updateUserCart() {\r\n    const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n\r\n    this.userDetails = this.storageService.getUser() as User;\r\n    this.cartInfo.userDetails = {\r\n      \"userId\": this.userDetails?.userId,\r\n      \"userName\": this.userDetails?.contact.name,\r\n      \"mobile\": this.userDetails?.contact.mobile,\r\n      \"email\": this.userDetails?.contact.email,\r\n    }\r\n    this.restService.getUserItems(this.userDetails.userId, \"CART\").subscribe((response: any) => {\r\n      const tempUserCart = response?.data?.[0]?.orderedItems ?? [];\r\n      localStorage.setItem('cartId', response.data?.[0]?.cartId);\r\n      this.cartInfo[\"cartId\"] = response.data?.[0]?.cartId;\r\n      this.cartInfo.billdetails['orraSchemeRedeemedAmount'] = response?.data?.[0]?.billdetails?.orraSchemeRedeemedAmount\r\n      this.cartInfo.billdetails['orraSchemeCode'] = response?.data?.[0]?.billdetails?.orraSchemeCode\r\n      this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.[0]?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n      if (response.data?.[0]?.billdetails?.orraSchemeCode)\r\n        this.selectMatureScheme = true\r\n      this.getCouponList();\r\n      if (response.data?.[0]?.orderedItems?.length > 0) {\r\n        this.mergeOrderItems(tempUserCart);\r\n        this.storageService.addAllProductsToCart(this.cartInfo.orderedItems).oncomplete = () => {\r\n\r\n          this.storageService.getUserCart().then((cartResponse) => {\r\n            cartResponse.onsuccess = (cartData: any) => {\r\n              if (!(localStorage.getItem(\"couponId\") == \"undefined\" || localStorage.getItem(\"couponId\") == \"null\"))\r\n                this.cartInfo.billdetails.couponId = localStorage.getItem(\"couponId\");\r\n              if (!(localStorage.getItem(\"couponCode\") == \"undefined\" || localStorage.getItem(\"couponCode\") == \"null\"))\r\n                this.cartInfo.billdetails.couponCode = localStorage.getItem(\"couponCode\");\r\n              const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n              restResponse.then((response: any) => {\r\n                this.cartInfo.billdetails.totalGrossValue = 0;\r\n                this.cartInfo.billdetails.totalTax = 0;\r\n                this.cartInfo.billdetails.deliveryCharges = 0;\r\n                this.cartInfo.billdetails.totalNetValue = 0;\r\n                this.cartInfo.totalAmount = 0;\r\n\r\n                this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n                this.USER_CART_ITEMS.forEach((item) => {\r\n                  this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n                  this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n                })\r\n                this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n                this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n                this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n                this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n                this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n                this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n                // this.storageService.addAllProductsToCart(this.cartInfo.orderedItems)\r\n                this.responseData = this.cartInfo;\r\n              })\r\n            }\r\n            cartResponse.onerror = (cartData: any) => {\r\n              this.messageService.add({ severity: 'error', summary: 'Error', detail: 'Failed to update cart details' });\r\n            }\r\n          })\r\n        }\r\n      } else {\r\n        this.storageService.getUserCart().then((cartResponse) => {\r\n          cartResponse.onsuccess = (cartData: any) => {\r\n\r\n            this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n            this.cartInfo.billdetails.totalGrossValue = 0;\r\n            this.cartInfo.billdetails.totalTax = 0;\r\n            this.cartInfo.billdetails.totalTaxAfterDiscount = cartData.billdetails?.totalTaxAfterDiscount ?? 0;\r\n            this.cartInfo.billdetails.deliveryCharges = 0;\r\n            this.cartInfo.billdetails.totalNetValue = 0;\r\n            this.cartInfo.totalAmount = 0;\r\n\r\n            this.USER_CART_ITEMS.forEach((item) => {\r\n              this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n              this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n            })\r\n            this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n            this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n            this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n            this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n            this.responseData = this.cartInfo;\r\n            this.restService.addItemToDB(this.responseData).subscribe((response: any) => {\r\n              localStorage.setItem('cartId', response.data?.cartId);\r\n              this.cartInfo[\"cartId\"] = response.data?.cartId;\r\n              this.responseData[\"cartId\"] = this.cartInfo[\"cartId\"];\r\n            })\r\n          }\r\n        })\r\n      }\r\n    })\r\n  }\r\n\r\n  getDefaultAddress() {\r\n    if ((this.userDetails?.addressDetailsList?.length || 0) == 0)\r\n      return;\r\n\r\n    this.selectedAddressIdx = this.userDetails?.addressDetailsList?.findIndex(address => address.default === true) ?? -1;\r\n    this.defaultAddress = this.selectedAddressIdx !== -1\r\n      ? this.userDetails?.addressDetailsList[this.selectedAddressIdx]\r\n      : this.userDetails?.addressDetailsList?.[0];\r\n  }\r\n  get stylesLayout() {\r\n    return { ...this.styles?.layout } as LayOutModel;\r\n  }\r\n\r\n  mergeOrderItems(syncedItems: any[]) {\r\n    for (let product of syncedItems) {\r\n      let itemFound = false;\r\n      for (let cartItem of this.cartInfo.orderedItems) {\r\n        if (cartItem.varientId === product.varientId) {\r\n          itemFound = true;\r\n          // cartItem.quantity = product.quantity;\r\n        }\r\n      }\r\n      if (!itemFound) {\r\n        this.cartInfo.orderedItems.push(product);\r\n      }\r\n    }\r\n  }\r\n\r\n  getCouponList() {\r\n    if (!this.cartInfo.cartId && !(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo.cartId = localStorage.getItem(\"cartId\");\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n\r\n    })\r\n  }\r\n  removeCoupon(event: MouseEvent) {\r\n    this.cartInfo.billdetails.couponId = \"\";\r\n    this.cartInfo.billdetails.couponCode = \"\";\r\n    const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    restResponse.then((response: any) => {\r\n\r\n      this.calculateCart(response);\r\n      localStorage.removeItem(\"couponId\");\r\n      localStorage.removeItem(\"couponCode\");\r\n      this.messageService.add({ severity: 'error', summary: 'Coupon', detail: 'Coupon Removed' });\r\n      this.cartInfo.billdetails.discountAmount = 0;\r\n      this.couponDialogRef?.close();\r\n    })\r\n    event.preventDefault();\r\n  }\r\n\r\n  getIndexDBData() {\r\n    this.storageService.getUserCart().then((cartResponse) => {\r\n      const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n      this.cartInfo.billdetails.totalGrossValue = 0;\r\n      this.cartInfo.billdetails.totalTax = 0;\r\n      this.cartInfo.billdetails.totalNetValue = 0;\r\n      this.cartInfo.totalAmount = 0;\r\n      this.cartInfo.billdetails.deliveryCharges = 0;\r\n\r\n      cartResponse.onsuccess = (cartData: any) => {\r\n        this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n        this.USER_CART_ITEMS.forEach((item) => {\r\n          this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n          this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n        })\r\n\r\n        this.cartInfo.billdetails.totalTaxAfterDiscount = cartData.billdetails?.totalTaxAfterDiscount ?? 0;\r\n        this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n        this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n        this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n        this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n        if (this.storageService.getUser())\r\n          this.updateUserCart();\r\n\r\n        this.responseData = this.cartInfo;\r\n      }\r\n    })\r\n  }\r\n  proceedToCheckout() {\r\n    if (this.storageService.getUser()) {\r\n      this.currentTab = \"ADDRESS\";\r\n      this.getDefaultAddress()\r\n      if (this.isMobile) {\r\n        document.body.scrollTop = 0;\r\n        document.documentElement.scrollTop = 0;\r\n      }\r\n\r\n    } else {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to order' });\r\n      this.router.navigate(['/login'], { queryParams: { cart: true } });\r\n    }\r\n  }\r\n  goToProductDetails(product: OrderedItems) {\r\n    this.router.navigate(['/details'], { queryParams: { id: product.itemId, varientId: product.varientId } });\r\n  }\r\n  proceedToListPage() {\r\n    this.router.navigate(['/']);\r\n  }\r\n  removeItem(item: OrderedItems) {\r\n\r\n    Swal.fire({\r\n      icon: \"warning\",\r\n      html: \"<span>You can move </span> <b>\" + item.itemName + \"</b> <span>to wishlist so you can buy later.</span>\",\r\n      confirmButtonText: \"Move to wishlist\",\r\n      showDenyButton: true,\r\n      showCloseButton: true,\r\n      denyButtonText: \"Delete item\",\r\n      denyButtonColor: \"#d5d5d5ff\",\r\n      allowOutsideClick: false,\r\n    }).then((response) => {\r\n      if (response.isConfirmed) {\r\n        if (this.cartType === 'SHOPPING') {\r\n          this.removeItemFromCart(item);\r\n        } else {\r\n          this.removeTrialItem(item)\r\n        }\r\n        this.moveItemToWishlist(item);\r\n      } else if (response.isDenied) {\r\n        if (this.cartType === 'SHOPPING') {\r\n          this.removeItemFromCart(item);\r\n        } else {\r\n          this.removeTrialItem(item)\r\n        }\r\n      }\r\n    })\r\n  }\r\n  private moveItemToWishlist(item: OrderedItems) {\r\n    this.cartService.addItemToFavFromCart(item);\r\n  }\r\n  private removeItemFromCart(item: OrderedItems) {\r\n    item.quantity = 0;\r\n    if (this.USER_CART_ITEMS)\r\n      this.USER_CART_ITEMS = this.USER_CART_ITEMS.filter((product: any) => product.varientId != item.varientId);\r\n    this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    this.responseData = this.cartInfo;\r\n    this.cartService.addItemFromCartPage(item, this.responseData).subscribe((response: any) => {\r\n      const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n      this.cartInfo.billdetails.totalGrossValue = 0;\r\n      this.cartInfo.billdetails.totalTax = 0;\r\n      this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n      this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n      this.cartInfo.billdetails.totalNetValue = 0;\r\n      this.cartInfo.totalAmount = 0;\r\n      this.cartInfo.billdetails.deliveryCharges = 0;\r\n      this.cartInfo.couponCode = response.data?.billdetails?.couponCode;\r\n      this.cartInfo.couponId = response.data?.billdetails?.couponId;\r\n\r\n      response?.data?.orderedItems.forEach((item: any) => {\r\n        this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n        this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n      })\r\n      this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n      this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n      this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n      this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    })\r\n  }\r\n  addToCart(item: OrderedItems, quantity: number) {\r\n    // if (type == 'ADD') {\r\n    //   item.quantity += 1;\r\n    // }\r\n    // else {\r\n    //   item.quantity -= 1;\r\n    // }\r\n    this.showReedemError = false\r\n    // item.quantity = quantity\r\n    if (item.quantity && item.quantity > 0) {\r\n      this.cartService.addItemFromCartPage(item, this.responseData).subscribe((response: any) => {\r\n        const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n        this.cartInfo.billdetails.totalGrossValue = 0;\r\n        this.cartInfo.billdetails.totalTax = 0;\r\n        this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n        this.cartInfo.billdetails.totalNetValue = 0;\r\n        this.cartInfo.totalAmount = 0;\r\n        this.cartInfo.billdetails.deliveryCharges = 0;\r\n        this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n\r\n        response?.data?.orderedItems.forEach((item: any) => {\r\n          this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n          this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n        })\r\n        this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n        this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n        this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n        this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n      })\r\n    } else {\r\n      this.removeItem(item);\r\n    }\r\n  }\r\n  cartId: any\r\n  placeOrderLoader: boolean = false;\r\n  async proceedToPayment() {\r\n    this.placeOrderLoader = true;\r\n    let result: any = \"\";\r\n\r\n    try {\r\n      const rawData = this.storageService.getReferralDetails();\r\n      const referralDetails = rawData ? JSON.parse(rawData) : {};\r\n\r\n      if (referralDetails && Object.keys(referralDetails).length > 0) {\r\n        result =\r\n          Object.values(referralDetails).find((item: any) =>\r\n            Array.isArray(item?.referralEvents) &&\r\n            item.referralEvents.includes('PRODUCT_PURCHASE')\r\n          ) || \"\";\r\n      }\r\n\r\n    } catch (error) {\r\n      console.error(\"Invalid referralDetails JSON\", error);\r\n    }\r\n\r\n    if (!this.storageService.getUser()) {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to order' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n\r\n    const isPaymentGatewayEnabled = localStorage.getItem(\"isPaymentGatewayEnabled\") ? localStorage.getItem(\"isPaymentGatewayEnabled\") == \"true\" : true;\r\n    const merchantId = localStorage.getItem('pMId') == \"null\" || localStorage.getItem('pMId') == \"undefined\" ? null : localStorage.getItem('pMId');\r\n\r\n    if (isPaymentGatewayEnabled && !merchantId) {\r\n      this.messageService.add({ severity: 'error', summary: 'Merchant onboarded', detail: 'Merchant is not onboarded' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n\r\n    const userDetail = this.storageService.getUser() as User;\r\n    const address = userDetail?.addressDetailsList[this.selectedAddressIdx] as Address;\r\n    if (address?.receiverName?.length == 0) {\r\n      this.messageService.add({ severity: 'error', summary: 'Payment Failure', detail: 'Please provide address details' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n    if (!(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo[\"cartId\"] = localStorage.getItem(\"cartId\");\r\n    else {\r\n      this.messageService.add({ severity: 'info', summary: 'Please wait', detail: 'We are processing your payment', life: 2000 });\r\n      await this.restService.addItemToDB(this.cartInfo).toPromise().then((response: any) => {\r\n        localStorage.setItem(\"cartId\", response.data?.cartId);\r\n        this.cartId = response.data?.cartId;\r\n        this.cartInfo[\"cartId\"] = response.data?.cartId;\r\n      })\r\n    }\r\n    if (this?.isPointsRedeeming === true) {\r\n      if ((this?.redemptionPoints?.pointsConvertedRupees === this.responseData?.totalAmount) || (this?.redemptionPoints?.pointsConvertedRupees > this.responseData?.totalAmount)) {\r\n        this.paymentWithCompletePoints()\r\n        return;\r\n      }\r\n    }\r\n    this.cartInfo[\"addressDetails\"] = address;\r\n    const updateAddress = await this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    const payload = {\r\n      \"userId\": userDetail?.userId,\r\n      \"cartId\": localStorage.getItem('cartId'),\r\n      // \"orderAmount\": this.isPointsRedeeming\r\n      //   ? Number(((this.responseData?.totalAmount ?? 0) - (this?.totalSavingAmt || 0)).toFixed(2))\r\n      //   : this.selectedVoucherAmount ? Number(((this.responseData?.totalAmount ?? 0) - (this?.selectedVoucherAmount || 0)).toFixed(2)) : Number((this.responseData?.totalAmount ?? 0).toFixed(2)),\r\n      \"orderAmount\": this.isPointsRedeeming\r\n        ? Number(((this.responseData?.totalAmount ?? 0) - (this?.totalSavingAmt || 0)).toFixed(2))\r\n        : this.couponValueType === 'AMOUNT'\r\n          ? Number(((this.responseData?.totalAmount ?? 0) - (this?.selectedVoucherAmount || 0)).toFixed(2))\r\n          : this.couponValueType === 'PERCENTAGE'\r\n            ? Number(((this.responseData?.totalAmount ?? 0) - (this?.percentageReduced || 0)).toFixed(2))\r\n            : Number((this.responseData?.totalAmount ?? 0).toFixed(2)),\r\n      \"isPaymentGatewayEnabled\": isPaymentGatewayEnabled,\r\n      \"contactDetails\": {\r\n        \"name\": address?.receiverName,\r\n        \"mobile\": address?.receiverPhone,\r\n        \"countryCode\": \"91\",\r\n        \"email\": address?.receiverEmail\r\n      },\r\n      \"paymentMerchantId\": merchantId,\r\n      \"isJewellery\": this?.isJewellery,\r\n      \"referralId\": result?.referralUniqueId,\r\n      \"rewardUsed\": this?.isPointsRedeeming ? \"REWARD_POINTS\" : this?.appliedVoucher ? \"VOUCHER\" : null,\r\n      \"pointsUsed\": this?.isPointsRedeeming ? this.usedPoints : 0,\r\n      \"pointsConvertedINR\": this?.isPointsRedeeming ? this.totalSavingAmt : 0,\r\n      \"voucherValue\": this.selectedVoucherAmount ? this.selectedVoucherAmount : this.percentageReduced ? this.percentageReduced : 0,\r\n      \"voucherId\": this?.appliedVoucher ? this.selectedVoucherId : null,\r\n      \"voucherCode\": this?.appliedVoucher ? this.selectedVoucherCode : ''\r\n    }\r\n    // console.log(payload)\r\n    // return\r\n    this.restService.createPaymentToken(payload).subscribe((paymentDetails: any) => {\r\n      if (isPaymentGatewayEnabled) {\r\n        this._eventService.cashFreeEvent.emit(paymentDetails);\r\n        this.placeOrderLoader = false;\r\n      }\r\n      else {\r\n\r\n        localStorage.removeItem(\"orderId\");\r\n        localStorage.removeItem(\"cartId\");\r\n        localStorage.removeItem(\"paymentFor\");\r\n        this.storageService.clearUserCart();\r\n        Swal.fire({\r\n          icon: \"success\",\r\n          title: \"Hurray\",\r\n          text: \"Order placed successfully\",\r\n          confirmButtonText: \"See Details\"\r\n        }).then((response) => {\r\n          if (response.isConfirmed) {\r\n            this.router.navigate(['/profile']);\r\n          }\r\n        })\r\n        this.placeOrderLoader = false;\r\n      }\r\n    }, (error) => {\r\n      if (error?.error?.code == 409) {\r\n        Swal.fire({\r\n          icon: \"info\",\r\n          html: \"<p>\" + error?.error?.message.replace(/ *\\([^)]*\\) */g, \"\") + \"</p>\",\r\n          showCloseButton: true\r\n        }).then(async (response) => {\r\n          this.currentTab = \"BAG\";\r\n        })\r\n      } else {\r\n        this.messageService.add({ severity: 'error', summary: 'Payment Failure', detail: 'Please try again' });\r\n      }\r\n      this.placeOrderLoader = false;\r\n    })\r\n  }\r\n\r\n\r\n  addressSelected(index: number) {\r\n    this.selectedAddressIdx = index;\r\n  }\r\n\r\n  isItemOutOfStock(product: OrderedItems) {\r\n    return false; // need condition\r\n  }\r\n  getKeys(object: Object): string[] {\r\n    if (object)\r\n      return Object.keys(object);\r\n    return [];\r\n  }\r\n\r\n  editSection() {\r\n\r\n    if (window.innerWidth <= 475)\r\n      return;\r\n\r\n    this._eventService.toggleEditorEvent.emit(false);\r\n    setTimeout(() => {\r\n      this._eventService.editSection.emit({ data: this.data });\r\n    }, 100);\r\n  }\r\n  closeWindow() {\r\n    this.dialogRef.close();\r\n  }\r\n  couponDialogRef: MatDialogRef<unknown> | null = null;\r\n  openDialog(container: any) {\r\n\r\n    if (this.cartInfo?.billdetails?.couponId)\r\n      return;\r\n\r\n    if (!this.cartInfo.cartId && !(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo.cartId = localStorage.getItem(\"cartId\");\r\n\r\n    // if (!this.cartInfo?.cartId) {\r\n    //   this.messageService.add({ severity: 'error', summary: 'You are not logged in', detail: 'Please login first to apply coupon' });\r\n    //   return;\r\n    // }\r\n\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n      console.log(this.couponList);\r\n      // if (!!this.userDetails)\r\n      this.couponDialogRef = this.matDialog.open(container, { panelClass: 'sidepanel-class' });\r\n      // else {\r\n      // this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to apply coupon' });\r\n      // }\r\n    })\r\n  }\r\n\r\n  listRedemptionCoupons: any;\r\n  appliedVoucher: any;\r\n  redemptionType: \"COUPONS\" | \"VOUCHERS\" = \"COUPONS\"\r\n  redemptionCouponType: \"REWARDS\" | \"DISCOUNTS\" = \"REWARDS\"\r\n  selectedVoucherId: any\r\n  selectedVoucherAmount: any\r\n  selectedVoucherCode: any\r\n  listRedemptionVouchers: any\r\n  selectedVoucherPercentage: any\r\n  percentageReduced: any\r\n  couponValueType: string = ''\r\n  addRedemptionCoupon(container: any) {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    const userDetails = (this.storageService.getUser() as User);\r\n    let userId = userDetails?.userId\r\n    let orderValue = this.responseData?.billdetails?.totalNetValue\r\n    // let businessId = '1f12df16-8154-6cea-85c5-fb616c47aaf4';\r\n    // let userId = '29d2b424-680c-46bd-b18f-b86b346eb1cf'; \r\n    // let orderValue = this.responseData?.billdetails?.totalNetValue;\r\n\r\n    this.restService.getRedeemPoints(businessId, userId, 'PRODUCT_PURCHASE', orderValue, false).subscribe({\r\n      next: (res: any) => {\r\n        console.log(res)\r\n        this.listRedemptionCoupons = res;\r\n      },\r\n      error: (err: any) => {\r\n        this.messageService.add({ severity: 'error', summary: 'Coupons Failed', detail: 'Failed to load Coupons' });\r\n      }\r\n    });\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n    })\r\n    this.couponDialogRef = this.matDialog.open(container, { panelClass: 'sidepanel-class' });\r\n  }\r\n\r\n  applyRedemptionCoupon(voucher: any) {\r\n    if (this.isPointsRedeeming) {\r\n      this.messageService.add({ severity: 'info', summary: 'Coupon not applicable', detail: 'You can not add a coupon when points are being redeemed' });\r\n      return;\r\n    }\r\n    if (this.appliedVoucher) {\r\n      this.removeRedemptionCoupon();\r\n    }\r\n    this.appliedVoucher = voucher;\r\n    this.selectedVoucherId = voucher.couponId;\r\n    this.selectedVoucherCode = voucher.voucherCode;\r\n    this.selectedVoucherPercentage = voucher.couponValue\r\n\r\n    let total = Number(this.responseData?.totalAmount) || 0;\r\n    let percentage = Number(this.selectedVoucherPercentage) || 0;\r\n    let amt = total * (percentage / 100);\r\n\r\n    if (voucher.couponValueType === 'PERCENTAGE') {\r\n      this.couponValueType = \"PERCENTAGE\"\r\n      if (amt > voucher.maxRedeemableAmount) {\r\n        this.percentageReduced = voucher.maxRedeemableAmount\r\n      }\r\n      else {\r\n        this.percentageReduced = amt\r\n      }\r\n    }\r\n    else {\r\n      this.couponValueType = \"AMOUNT\"\r\n      this.selectedVoucherAmount = voucher.couponValue;\r\n    }\r\n\r\n    this.closeDialogRef();\r\n    Swal.fire({\r\n      icon: \"success\",\r\n      title: `You saved ${this.selectedVoucherAmount ? '₹' : ''} ${this.selectedVoucherAmount ? this.selectedVoucherAmount : this.selectedVoucherPercentage} ${this.selectedVoucherAmount ? '' : '%'} on this payment`,\r\n      text: `Coupon code ${this.selectedVoucherCode} has been applied successfully`,\r\n      confirmButtonText: \"YAY!\",\r\n      confirmButtonColor: \"#111\",\r\n    }).then((res) => {\r\n      if (res.isConfirmed || res.isDismissed) {\r\n        // popup closed\r\n      }\r\n    })\r\n  }\r\n\r\n  removeRedemptionCoupon(event?: Event) {\r\n    event?.stopPropagation();\r\n    this.appliedVoucher = null;\r\n    this.selectedVoucherId = null;\r\n    this.selectedVoucherCode = null;\r\n    this.selectedVoucherAmount = null;\r\n  }\r\n\r\n  searchIfApplicable() { }\r\n  closeDialogRef() {\r\n    this.couponDialogRef?.close();\r\n  }\r\n  applyCoupon(coupon: Coupon) {\r\n\r\n    if (!coupon.applicable)\r\n      return;\r\n\r\n    this.cartInfo.billdetails.couponCode = coupon.couponCode;\r\n    this.cartInfo.billdetails.couponId = coupon.couponId;\r\n    const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    restResponse.then((response: any) => {\r\n\r\n      localStorage.setItem(\"couponId\", coupon.couponId);\r\n      localStorage.setItem(\"couponCode\", coupon.couponCode);\r\n      this.calculateCart(response);\r\n\r\n      this.messageService.add({ severity: 'success', summary: 'Coupon', detail: 'Coupon Applied' });\r\n      this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n      this.couponDialogRef?.close();\r\n    })\r\n  }\r\n  calculateCart(response: any) {\r\n    const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n    this.cartInfo.billdetails.totalGrossValue = 0;\r\n    this.cartInfo.billdetails.totalTax = 0;\r\n    this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n    this.cartInfo.billdetails.deliveryCharges = 0;\r\n    this.cartInfo.billdetails.totalNetValue = 0;\r\n    this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n    this.cartInfo.totalAmount = 0;\r\n\r\n    if (this.USER_CART_ITEMS) {\r\n\r\n      this.USER_CART_ITEMS.forEach((item) => {\r\n        this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n        this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n      })\r\n      this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n      this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n      this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n      this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    }\r\n    this.responseData = this.cartInfo;\r\n  }\r\n\r\n  getTaxAmount(): number {\r\n    return !this.cartInfo.billdetails?.couponId ? (this.cartInfo.billdetails.totalTax ?? 0) : (this.cartInfo.billdetails?.totalTaxAfterDiscount ?? 0);\r\n  }\r\n\r\n  get getAddressList() {\r\n    return this.userDetails ? [...this.userDetails?.addressDetailsList] : [];\r\n  }\r\n  get isMobile() {\r\n    return window.innerWidth <= 475;\r\n  }\r\n  get currency(): string {\r\n    return BUSINESS_CONSTANTS.CURRENCY;\r\n  }\r\n\r\n  changeAddress() {\r\n    this.matDialog.open(AddressListComponent, { panelClass: 'sidepanel-class', data: { addressList: this.getAddressList } }).afterClosed().subscribe((res: any) => {\r\n      this.userDetails = this.storageService.getUser() as User;\r\n      this.getDefaultAddress();\r\n    })\r\n  }\r\n\r\n  addAddress() {\r\n    this.matDialog.open(AddressComponent, { panelClass: ['sidepanel-class', 'address-class'], data: { addressList: this.getAddressList, 'editIndex': -1 } }).afterClosed().subscribe((res: any) => {\r\n      this.userDetails = this.storageService.getUser() as User;\r\n      this.getDefaultAddress();\r\n    })\r\n  }\r\n\r\n  scroll(e: WheelEvent) {\r\n    const d = this.d2.nativeElement;\r\n    const atTop = d.scrollTop === 0;\r\n    const atBottom = d.scrollTop >= d.scrollHeight - d.clientHeight;\r\n    if ((atTop && e.deltaY < 0) || (atBottom && e.deltaY > 0)) {\r\n      return;\r\n    }\r\n    e.preventDefault();\r\n    d.scrollTop = Math.max(0, Math.min(d.scrollTop + e.deltaY * 2, d.scrollHeight - d.clientHeight));\r\n  }\r\n  selectedRedmpationData: any;\r\n  selectScheme() {\r\n    let dialog = this.matDialog.open(SchemeSelectionComponent, {});\r\n    dialog.afterClosed().subscribe((response: any) => {\r\n      this.selectedRedemption = true;\r\n      this.selectedRedmpationData = response;\r\n    });\r\n  }\r\n  scheduleVideoCall(items: any) {\r\n    this.matDialog.open(ScheduleVideoCallComponent, { panelClass: 'sidepanel-class', data: { data: this.data, orderItems: items } });\r\n  }\r\n  getButtonId(index: number) {\r\n    return this.data?.action?.buttons[index]?.id ?? \"\";\r\n  }\r\n  getButtonStyle(index: number) {\r\n    return this.data?.action?.buttons[index]?.styles;\r\n  }\r\n\r\n  changeQuantity(quantity: any, item: OrderedItems) {\r\n    this.addToCart(item, quantity.target.value);\r\n  }\r\n\r\n  removeTrialItem(item: OrderedItems) {\r\n    this.trialCartItem = this.trialCartItem?.filter((product: OrderedItems) => item.varientId != product.varientId) ?? [];\r\n\r\n    const user = this.storageService.getUser()\r\n    if (user) {\r\n      let request: syncItemToServerDBRequest = new syncItemToServerDBRequest(user.userId, 'TRIAL_CART', [item])\r\n      this.restService.deleteItemFromCart(request).subscribe((res: any) => {\r\n        this.messageService.add({ severity: 'success', summary: 'Trial Product', detail: 'Deleted successfully' });\r\n      })\r\n    } else {\r\n      this.storageService.removeProductFromTrialCart(item.varientId)\r\n      this.messageService.add({ severity: 'success', summary: 'Trial Product', detail: 'Deleted successfully' });\r\n    }\r\n  }\r\n\r\n  bookAppointment() {\r\n    const user: User | null = this.storageService.getUser();\r\n    if (!user) {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to Book' });\r\n      this.router.navigate(['/login'], { queryParams: { tryAtHome: true } });\r\n      return;\r\n    }\r\n\r\n    this.router.navigate(['/home-appointment'])\r\n  }\r\n  showReedemError: boolean = false;\r\n  vaildAmount: number = 0\r\n  redeemScheme(scheme: any, action: boolean) {\r\n    if (((this.responseData?.totalAmount ?? 0) - (this.responseData?.billdetails?.discountAmount ?? 0)) < scheme.amount) {\r\n      this.messageService.add({ severity: 'error', summary: 'Scheme Redeem', detail: 'Cart amount should be more that redeem amount' });\r\n      return;\r\n    }\r\n\r\n    this.restService.redeemScheme(scheme, this.cartInfo.cartId, action).subscribe((res: any) => {\r\n      this.cartInfo.billdetails.orraSchemeRedeemedAmount = scheme.amount\r\n      this.cartInfo.billdetails.orraSchemeCode = scheme.GPPId\r\n    })\r\n  }\r\n\r\n  getUrl() {\r\n    return window?.location?.origin?.includes('caratlane') || window?.location?.origin?.includes('orra')\r\n  }\r\n  get fontColor(): string {\r\n    let color = this.styles?.background?.accentColor;\r\n    if (!color) return '#000';\r\n\r\n    // if gradient, extract first hex color\r\n    const gradientMatch = color.match(/#([0-9a-fA-F]{6})/);\r\n    if (gradientMatch) {\r\n      color = gradientMatch[0];\r\n    }\r\n\r\n    color = color.replace('#', '');\r\n\r\n    const r = parseInt(color.substring(0, 2), 16);\r\n    const g = parseInt(color.substring(2, 4), 16);\r\n    const b = parseInt(color.substring(4, 6), 16);\r\n\r\n    const brightness = (r * 299 + g * 587 + b * 114) / 1000;\r\n\r\n    return brightness > 128 ? '#000' : '#fff';\r\n  }\r\n  get accentBackground(): string {\r\n    const bg = this.styles?.background;\r\n\r\n    if (!bg) return '';\r\n\r\n    if (bg.accentBackgroundType === 'Solid') {\r\n      return bg.accentColor;\r\n    }\r\n\r\n    const angle = this.getGradientDirection(bg.gradientDirection);\r\n\r\n    return angle\r\n      ? `linear-gradient(${angle}, ${bg.accentColor}, ${bg.secondaryAccentColor})`\r\n      : `linear-gradient(${bg.accentColor}, ${bg.secondaryAccentColor})`;\r\n  }\r\n  getGradientDirection(direction: string | undefined): string {\r\n    switch (direction) {\r\n      case 'DOWN':\r\n        return ''; // default top → bottom (no angle needed)\r\n\r\n      case 'RIGHT':\r\n        return '90deg';\r\n\r\n      case 'DIAGONAL_RIGHT':\r\n        return '45deg';\r\n\r\n      case 'DIAGONAL_LEFT':\r\n        return '135deg';\r\n\r\n      default:\r\n        return ''; // fallback\r\n    }\r\n  }\r\n  increaseQty(item: any) {\r\n    if (!this.edit) {\r\n      item.quantity++;\r\n      this.addToCart(item, item.quantity);\r\n    }\r\n  }\r\n\r\n  decreaseQty(item: any) {\r\n    if (!this.edit) {\r\n      item.quantity--;\r\n      this.addToCart(item, item.quantity);\r\n    }\r\n  }\r\n\r\n  referEarnExist: boolean = false;\r\n  isPointsRedeeming: boolean = false;\r\n  redemptionPoints: any\r\n  checkAppInstalled() {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    this.restService.checkAppInstalled(businessId, 'Refer and Earn').subscribe({\r\n      next: (res: any) => {\r\n        this.referEarnExist = res.data\r\n        this.getRedeemPoints()\r\n      },\r\n      error: (err: any) => {\r\n\r\n      }\r\n    })\r\n  }\r\n\r\n  totalSavingAmt: number = 0\r\n  totalSavingPoints: number = 0\r\n  pointsConverted: number = 0\r\n  usedPoints: any\r\n  getRedeemPoints() {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    const userDetails = (this.storageService.getUser() as User);\r\n    let userId = userDetails?.userId\r\n    let orderValue = this.responseData?.billdetails?.totalNetValue\r\n    // let businessId = '1f12df16-8154-6cea-85c5-fb616c47aaf4'\r\n    // let userId = '29d2b424-680c-46bd-b18f-b86b346eb1cf'\r\n    // let orderValue = this.responseData?.billdetails?.totalNetValue\r\n\r\n    this.restService.getRedeemPoints(businessId, userId, 'PRODUCT_PURCHASE', orderValue, true).subscribe({\r\n      next: (res: any) => {\r\n        this.redemptionPoints = res\r\n        this.pointsConverted = res.availablePoints / res.pointsConvertedRupees;\r\n        this.totalSavingAmt = this.getRemainingRupees\r\n        this.totalSavingPoints = this.getRemainingPoints\r\n        this.usedPoints = this.getRemainingRupees * this.pointsConverted;\r\n      },\r\n      error: (err: any) => {\r\n\r\n      }\r\n    })\r\n  }\r\n\r\n  onPointsRedeemingChange(event: Event) {\r\n    if (this.appliedVoucher) {\r\n      event.preventDefault();\r\n      this.messageService.add({\r\n        severity: 'info',\r\n        summary: 'Points Redeem',\r\n        detail: 'You can not redeem points when a coupon is applied. Please remove the coupon to redeem points'\r\n      });\r\n    } else {\r\n      this.isPointsRedeeming = !this.isPointsRedeeming;\r\n    }\r\n  }\r\n\r\n  // For repemption\r\n  get getRemainingPoints() {\r\n    return this?.responseData?.totalAmount > this?.redemptionPoints.pointsConvertedRupees ? 0 : (this?.redemptionPoints.availablePoints - this?.responseData?.totalAmount * this.pointsConverted)\r\n  }\r\n\r\n  get getRemainingRupees() {\r\n    return this?.responseData?.totalAmount > this?.redemptionPoints?.pointsConvertedRupees ? this?.redemptionPoints?.pointsConvertedRupees : this?.responseData?.totalAmount\r\n  }\r\n\r\n  paymentWithCompletePoints() {\r\n    let cartId = localStorage.getItem('cartId')\r\n    let payload = {\r\n      rewardUsed: this?.isPointsRedeeming ? \"REWARD_POINTS\" : this?.appliedVoucher ? \"VOUCHER\" : null,\r\n      pointsUsed: this?.isPointsRedeeming ? this.usedPoints : 0,\r\n      pointsConvertedINR: this?.isPointsRedeeming ? this.totalSavingAmt : 0,\r\n      voucherValue: this.selectedVoucherAmount ? this.selectedVoucherAmount : this.percentageReduced ? this.percentageReduced : 0,\r\n      voucherId: this?.appliedVoucher ? this.selectedVoucherId : null,\r\n      voucherCode: this?.appliedVoucher ? this.selectedVoucherCode : '',\r\n    }\r\n    this.restService.paymentWithCompletePoints(cartId, payload).subscribe({\r\n      next: (res: any) => {\r\n        localStorage.removeItem(\"orderId\");\r\n        localStorage.removeItem(\"cartId\");\r\n        localStorage.removeItem(\"paymentFor\");\r\n        this.storageService.clearUserCart();\r\n        Swal.fire({\r\n          icon: \"success\",\r\n          title: \"Hurray\",\r\n          text: \"Order placed successfully\",\r\n          confirmButtonText: \"See Details\"\r\n        }).then((response) => {\r\n          if (response.isConfirmed) {\r\n            this.router.navigate(['/profile']);\r\n          }\r\n        })\r\n      },\r\n      error: (err: any) => {\r\n        this.messageService.add({ severity: 'error', summary: 'Order Failed', detail: 'Failed to place order' });\r\n      }\r\n    })\r\n  }\r\n\r\n}\r\n","<ng-container *ngIf=\"!isLoading\">\r\n  <p-toast position=\"bottom-right\" [baseZIndex]=\"10000000000\" [autoZIndex]=\"true\"\r\n    [showTransformOptions]=\"isMobile ? 'translateY(-100%)' : ''\"></p-toast>\r\n\r\n  <ng-container *ngIf=\"data\">\r\n    <section [id]=\"data?.id\" [simpoLayout]=\"styles?.layout\" [id]=\"data?.id\"\r\n      [attr.class]=\"isMobile ? 'py-5 position-relative' : 'position-relative'\" simpoHover\r\n      (hovering)=\"showEditTabs($event)\" [attr.style]=\"customClass\"\r\n      [ngClass]=\"!responseData?.orderedItems?.length ? 'no-items' : ''\">\r\n      <div class=\"d-flex align-items-center justify-content-center m-auto mb-4\"\r\n        [style.marginTop.px]=\"isMobile ? '': '50'\" [style.width.%]=\"isMobile ? '90' : ''\"\r\n        *ngIf=\"responseData?.orderedItems?.length && currentTab === 'ADDRESS'\">\r\n        <span class=\"timeline\" (click)=\"currentTab = 'BAG'\">Bag</span>\r\n        <div class=\"bar\"></div>\r\n        <span class=\"timeline isActive\">Address</span>\r\n        <div class=\"bar\"></div>\r\n        <span class=\"timeline\" style=\"cursor: auto;\">Payment</span>\r\n      </div>\r\n      <div class=\"cart-tab-parent w-100\" *ngIf=\"currentTab == 'BAG' && ecomConfigs?.appointmentBookingEnabled\">\r\n        <!-- && ecomConfigs?.appointmentBookingEnabled\" -->\r\n        <div class=\"cart-tabs\" [id]=\"data?.id\">\r\n          <div class=\"selected-cart-tab\" [ngClass]=\"{'selected-cart-tab': cartType==='SHOPPING'}\"\r\n            (click)=\"cartType='SHOPPING'\">Shopping Cart ({{responseData?.orderedItems?.length ?? 0}})</div>\r\n          <div [ngClass]=\"{'selected-cart-tab': cartType==='TRIAL'}\" (click)=\"cartType='TRIAL'\">Trial Cart\r\n            ({{trialCartItem?.length ?? 0}})</div>\r\n        </div>\r\n      </div>\r\n      <div class=\"cart-parent\" [spacingHorizontal]=\"stylesLayout\" *ngIf=\"currentTab === 'BAG'\" [id]=\"data?.id\"\r\n        [simpoAnimation]=\"styles?.animation\">\r\n        <ng-container>\r\n          <ng-container *ngIf=\"cartType === 'SHOPPING'\">\r\n            <ng-container\r\n              *ngTemplateOutlet=\"(responseData?.orderedItems?.length || 0) > 0 ? CARTPAGE : EMPTYITEM\"></ng-container>\r\n          </ng-container>\r\n          <ng-container *ngIf=\"cartType === 'TRIAL'\">\r\n            <ng-container *ngTemplateOutlet=\"(trialCartItem?.length || 0) > 0 ? CARTPAGE : EMPTYITEM\"></ng-container>\r\n          </ng-container>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"d-flex checkoutPage\"\r\n        *ngIf=\"(responseData?.orderedItems?.length || 0) > 0 && currentTab === 'ADDRESS'\">\r\n        <ng-container *ngTemplateOutlet=\"CHECKOUTPAGE\">\r\n        </ng-container>\r\n      </div>\r\n\r\n\r\n      <div [ngClass]=\"{'hover_effect': edit}\" *ngIf=\"showEditors\">\r\n        <simpo-hover-elements [data]=\"data\" [index]=\"index\" [editOptions]=\"edit\"\r\n          [isEcommerce]=\"true\"></simpo-hover-elements>\r\n      </div>\r\n      <div *ngIf=\"showDelete\" [ngClass]=\"{'hover_effect': delete}\">\r\n        <simpo-delete-hover-element [data]=\"data\" [index]=\"index\"></simpo-delete-hover-element>\r\n      </div>\r\n\r\n    </section>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"!data\">\r\n    <section class=\"cart-window\">\r\n      <div class=\"heading-large lh-2 mb-3 header-sec\">\r\n        <div class=\"d-flex align-items-center\">\r\n          <mat-icon (click)=\"closeWindow()\">keyboard_arrow_left</mat-icon>\r\n          <span>Your Cart</span>\r\n        </div>\r\n        <div class=\"saving\"></div>\r\n      </div>\r\n      <div class=\"offers\">\r\n        <div class=\"d-flex align-items-center\" style=\"gap: 5px;\">\r\n          <img src=\"https://i.postimg.cc/htY55sqY/discount.png\" alt=\"\" height=\"20\" width=\"20\">\r\n          <span>Avail Offers / Coupons</span>\r\n        </div>\r\n        <mat-icon>keyboard_arrow_right</mat-icon>\r\n      </div>\r\n      <div class=\"small-items\">\r\n        <ng-container *ngFor=\"let item of responseData?.orderedItems\">\r\n          <div class=\"small-item\">\r\n            <div class=\"d-flex\" style=\"gap: 5px;\">\r\n              <div class=\"h-100\" style=\"padding: 0px; width: fit-content;\">\r\n                <img loading=\"lazy\" onerror=\"this.src='https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\"\r\n                  class=\"small-product-img\"\r\n                  [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" alt=\"\"\r\n                  (click)=\"goToProductDetails(item)\">\r\n              </div>\r\n              <div class=\"small-item-name trim-text\">{{ item.itemName | titlecase }}</div>\r\n              <div class=\"small-item-quantity\">\r\n                <span class=\"cursor\">-</span>\r\n                <span>{{item.quantity}}</span>\r\n                <span class=\"cursor\">+</span>\r\n              </div>\r\n              <div class=\"small-item-price\">\r\n                <div class=\"price-with-tax\">\r\n                  <span [innerHTML]='currency'></span> {{(item.sellingPrice) | number: '1.0-2'}}\r\n                </div>\r\n                <!-- <div class=\"price-with-tax\">\r\n                  <span [innerHTML]='currency'></span> {{(item.selling) | number: '1.0-2'}}\r\n                </div> -->\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"fotter-sec\">\r\n        <div class=\"delivery-add d-flex\">\r\n          <mat-icon>home</mat-icon>\r\n          <div class=\"address\">Tetsting</div>\r\n        </div>\r\n        <button class=\"payment-btn\" [disabled]=\"cartInfo.addressDetails\" (click)=\"proceedToCheckout()\"> <span\r\n            style=\"margin-right: 5px;\">Click to Pay</span> <span [innerHtml]='currency'></span>\r\n          {{(responseData?.totalAmount ?? 0) | number: '1.0-2'}}</button>\r\n      </div>\r\n    </section>\r\n  </ng-container>\r\n</ng-container>\r\n\r\n<ngx-skeleton-loader *ngIf=\"isLoading\" count=\"1\" appearance=\"circle\" [theme]=\"{\r\n  width: '100%',\r\n  height: '40vh',\r\n  'border-radius': '10px',\r\n  'position': 'relative',\r\n  'right': '5px'\r\n}\">\r\n</ngx-skeleton-loader>\r\n\r\n<ng-template #CouponList>\r\n  <section class=\"coupons-listing-section\">\r\n    <div class=\"coupon-heading\">\r\n      <div class=\"back-btn\" (click)=\"closeDialogRef()\">\r\n        <mat-icon>keyboard_arrow_left</mat-icon>\r\n      </div>\r\n      <div class=\"header-text\">Apply Coupon</div>\r\n    </div>\r\n    <!-- <div class=\"coupon-search-sec\">\r\n      <input type=\"text\" placeholder=\"Type Coupon Code\" [(ngModel)]=\"enteredCouponCode\">\r\n      <div class=\"apply-btn-search\" (click)=\"searchIfApplicable()\">Apply</div>\r\n    </div> -->\r\n    <div class=\"coupon-listing\">\r\n      <ng-container *ngIf=\"couponList.length > 0; else showEmptyScreen\">\r\n        <ng-container *ngFor=\"let couponDetails of couponList; let idx = index\">\r\n          <div class=\"coupon-details\"\r\n            [ngStyle]=\"{'background-color': !couponDetails.applicable ? '#FFF2F4' : '#EDFFFA'}\"\r\n            *ngIf=\"couponDetails?.status\">\r\n            <div class=\"details__coupon-heading\">\r\n              <div class=\"coupon-brief\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name\" [ngStyle]=\"{'color': !couponDetails.applicable ? '#DB1A1A' : '#097D5F'}\">\r\n                    {{ couponDetails.couponCode | uppercase }}</div>\r\n                  <div class=\"coupon-desc\">{{ couponDetails.discountDescription | titlecase }}</div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn\" [style.opacity]=\"couponDetails.applicable ? '1' : '0.3'\"\r\n                    [ngStyle]=\"{'cursor': couponDetails.applicable ? 'pointer' : ''}\"\r\n                    (click)=\"applyCoupon(couponDetails)\">Apply</div>\r\n                </div>\r\n              </div>\r\n              <!-- <div class=\"coupon-toggle-details-btn\" (click)=\"couponDetails.status = !couponDetails.status\">\r\n                <span class=\"hide-details-btn\" *ngIf=\"couponDetails.status\">Hide details</span>\r\n                <div class=\"show-details-btn\" *ngIf=\"!couponDetails.status\">View details</div>\r\n              </div> -->\r\n            </div>\r\n            <ng-container>\r\n              <!-- *ngIf=\"couponDetails.status\" -->\r\n              <div class=\"details-divider\"></div>\r\n              <ul class=\"details__coupon-terms\">\r\n                <li>Offer valid from {{ couponDetails.validFrom | date }} - {{ couponDetails.validTo | date }}</li>\r\n              </ul>\r\n            </ng-container>\r\n          </div>\r\n        </ng-container>\r\n      </ng-container>\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Coupon Available</div>\r\n          <div class=\"empty-screen__secondary-text\">\r\n            Looks like there are no coupons at the moment\r\n          </div>\r\n          <!-- <div class=\"empty-screen__button\">Explore</div> -->\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #RedemptionVouchers>\r\n  <section class=\"vouchers-listing-section d-flex flex-column\">\r\n    <div class=\"coupon-heading d-flex align-items-center gap-2 p-3 fs-18 fw-600 border-bottom\">\r\n      <div class=\"back-btn cursor-pointer d-flex align-items-center\" (click)=\"closeDialogRef()\">\r\n        <mat-icon>keyboard_arrow_left</mat-icon>\r\n      </div>\r\n      <div class=\"header-text\">Coupons & Vouchers</div>\r\n    </div>\r\n\r\n    <!-- <div class=\"d-flex align-items-center tab-container justify-content-between gap-2 p-3\">\r\n      <div class=\"redemption-type fs-16 fw-500 cursor-pointer\" [ngClass]=\"{'active-type': redemptionType === 'COUPONS'}\"\r\n        (click)=\"redemptionType = 'COUPONS'\">\r\n        Coupons\r\n      </div>\r\n      <div class=\"redemption-type fs-16 fw-500 cursor-pointer\" [ngClass]=\"{'active-type': redemptionType === 'VOUCHERS'}\"\r\n        (click)=\"redemptionType = 'VOUCHERS'\">\r\n        Vouchers\r\n      </div>\r\n    </div> -->\r\n\r\n    <div class=\"coupon-listing d-flex flex-column gap-3 pt-3\" *ngIf=\"redemptionType === 'COUPONS'\">\r\n      <div class=\"d-flex align-items-center tab-container gap-3\">\r\n        <div class=\"coupon-type fs-16 fw-500 cursor-pointer\"\r\n          [ngClass]=\"{'active-coupon': redemptionCouponType === 'REWARDS'}\" (click)=\"redemptionCouponType = 'REWARDS'\">\r\n          Rewards\r\n        </div>\r\n        <div class=\"coupon-type fs-16 fw-500 cursor-pointer\"\r\n          [ngClass]=\"{'active-coupon': redemptionCouponType === 'DISCOUNTS'}\"\r\n          (click)=\"redemptionCouponType = 'DISCOUNTS'\">\r\n          Discounts\r\n        </div>\r\n      </div>\r\n      <ng-container *ngIf=\"redemptionCouponType === 'REWARDS'\">\r\n        <ng-container *ngIf=\"(listRedemptionCoupons?.vouchers?.length > 0) ; else showEmptyScreen\">\r\n          <ng-container *ngFor=\"let voucher of listRedemptionCoupons?.vouchers; let idx = index\">\r\n            <div class=\"voucher-details\" *ngIf=\"!voucher.utilised\">\r\n\r\n              <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name fs-16 fw-600 mb-1\">{{ voucher.voucherName }}</div>\r\n                  <div class=\"coupon-desc fs-12 text-secondary\">\r\n                    Get {{ voucher.couponValueType === 'FIXED' ? '₹' + voucher.couponValue : voucher.couponValue + '%'\r\n                    }}\r\n                    off on your payment\r\n                  </div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\" (click)=\"applyRedemptionCoupon(voucher)\">\r\n                    Apply</div>\r\n                </div>\r\n              </div>\r\n\r\n              <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n                <div class=\"code-label\">Code</div>\r\n                <div class=\"code-value\">{{ voucher.voucherCode }}</div>\r\n              </div>\r\n\r\n              <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n                <span class=\"min-order\">Min: ₹{{ voucher.minOrderValue | number }}</span>\r\n                <span class=\"separator text-secondary\">|</span>\r\n                <span class=\"validity\">\r\n                  <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                  Until {{ voucher.issuedDate | date: 'MMM dd, yyyy' }}\r\n                </span>\r\n                <span class=\"separator text-secondary\" *ngIf=\"voucher.maxRedeemableAmount\">|</span>\r\n                <span class=\"min-order\" *ngIf=\"voucher.maxRedeemableAmount\">Max Redeemable Amount: ₹{{\r\n                  voucher.maxRedeemableAmount | number }}</span>\r\n              </div>\r\n\r\n              <!-- <div class=\"terms-link\">View terms & conditions</div> -->\r\n            </div>\r\n          </ng-container>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-container *ngIf=\"redemptionCouponType === 'DISCOUNTS'\">\r\n        <ng-container *ngIf=\"(couponList.length > 0); else showEmptyDiscounts\">\r\n          <ng-container *ngFor=\"let couponDetails of couponList; let idx = index\">\r\n            <div class=\"voucher-details\" *ngIf=\"couponDetails?.status\">\r\n\r\n              <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name fs-16 fw-600 mb-1\"\r\n                    [ngStyle]=\"{'color': !couponDetails.applicable ? '#DB1A1A' : '#097D5F'}\">\r\n                    {{ couponDetails.couponCode | uppercase }}\r\n                  </div>\r\n                  <div class=\"coupon-desc fs-12 text-secondary\">\r\n                    {{ couponDetails.discountDescription | titlecase }}\r\n                  </div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\"\r\n                    [style.opacity]=\"couponDetails.applicable ? '1' : '0.3'\"\r\n                    [ngStyle]=\"{'cursor': couponDetails.applicable ? 'pointer' : 'not-allowed'}\"\r\n                    (click)=\"applyCoupon(couponDetails)\">\r\n                    Apply\r\n                  </div>\r\n                </div>\r\n              </div>\r\n\r\n              <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n                <div class=\"code-label\">Code</div>\r\n                <div class=\"code-value\">{{ couponDetails.couponCode | uppercase }}</div>\r\n              </div>\r\n\r\n              <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n                <span class=\"validity\">\r\n                  <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                  {{ couponDetails.validFrom | date }} - {{ couponDetails.validTo | date }}\r\n                </span>\r\n              </div>\r\n\r\n            </div>\r\n          </ng-container>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-template #showEmptyDiscounts>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Discount Coupons Available</div>\r\n          <div class=\"empty-screen__secondary-text\">\r\n            Looks like there are no discount coupons at the moment\r\n          </div>\r\n          <!-- <div class=\"empty-screen__button\">Explore</div> -->\r\n        </div>\r\n      </ng-template>\r\n\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Coupons Available</div>\r\n          <div class=\"empty-screen__secondary-text\">Looks like there are no coupons</div>\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n\r\n    <div class=\"coupon-listing d-flex flex-column gap-3\" *ngIf=\"redemptionType === 'VOUCHERS'\">\r\n      <ng-container *ngIf=\"listRedemptionVouchers?.vouchers?.length > 0; else showEmptyScreen\">\r\n        <ng-container *ngFor=\"let voucher of listRedemptionVouchers?.vouchers; let idx = index\">\r\n          <div class=\"voucher-details\" *ngIf=\"!voucher.utilised\">\r\n\r\n            <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n              <div class=\"coupon-brief__left-sec\">\r\n                <div class=\"coupon-name fs-16 fw-600 mb-1\">{{ voucher.voucherName }}</div>\r\n                <div class=\"coupon-desc fs-12 text-secondary\">\r\n                  Get {{ voucher.couponValueType === 'FIXED' ? '₹' + voucher.couponValue : voucher.couponValue + '%' }}\r\n                  off on your payment\r\n                </div>\r\n              </div>\r\n              <div class=\"coupon-brief__right-sec\">\r\n                <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\" (click)=\"applyRedemptionCoupon(voucher)\">Apply\r\n                </div>\r\n              </div>\r\n            </div>\r\n\r\n            <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n              <div class=\"code-label\">Code</div>\r\n              <div class=\"code-value\">{{ voucher.voucherCode }}</div>\r\n            </div>\r\n\r\n            <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n              <span class=\"min-order\">Min: ₹{{ voucher.minOrderValue | number }}</span>\r\n              <span class=\"separator text-secondary\">|</span>\r\n              <span class=\"validity\">\r\n                <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                Until {{ voucher.issuedDate | date: 'MMM dd, yyyy' }}\r\n              </span>\r\n            </div>\r\n\r\n            <!-- <div class=\"terms-link\">View terms & conditions</div> -->\r\n          </div>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Vouchers Available</div>\r\n          <div class=\"empty-screen__secondary-text\">Looks like there are no vouchers</div>\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #CARTPAGE>\r\n  <div class=\"container\">\r\n    <div class=\"main-content\">\r\n      <div class=\"promo-banner mb-3\" [id]=\"data?.id\" *ngIf=\"cartType === 'SHOPPING' && ecomConfigs?.videoCallEnabled\">\r\n        <!-- && ecomConfigs?.videoCallEnabled\" -->\r\n        <div class=\"promo-text\">\r\n          <h3>See It Before You Buy It</h3>\r\n          <p>Experience our designs in detail via video call</p>\r\n        </div>\r\n        <button class=\"see-live-btn\" (click)=\"scheduleVideoCall(responseData?.orderedItems)\">\r\n          <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 24 24\" fill=\"none\"\r\n            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"\r\n            class=\"lucide lucide-video\">\r\n            <path d=\"m22 8-6 4 6 4V8Z\" />\r\n            <rect width=\"14\" height=\"12\" x=\"2\" y=\"6\" rx=\"2\" ry=\"2\" />\r\n          </svg>\r\n          SEE IT LIVE\r\n        </button>\r\n      </div>\r\n\r\n      <div class=\"cart-items\">\r\n        <div class=\"cart-header\">\r\n          <h2>Your Cart</h2>\r\n        </div>\r\n        <ng-container\r\n          *ngTemplateOutlet=\"CARTITEM;context:{data: cartType === 'SHOPPING' ? responseData?.orderedItems : trialCartItem}\"></ng-container>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"sidebar\">\r\n      <div class=\"reedem-section d-flex flex-column align-items-center\" *ngIf=\"cartType != 'TRIAL' && getUrl()\">\r\n        <div class=\"justify-content-between d-flex align-items-center w-100 redeem-section-text\">Redeem Section Amount\r\n          <div class=\"toogle-switch\">\r\n            <div class=\"form-check form-switch\">\r\n              <input class=\"form-check-input cursor-pointer\" type=\"checkbox\" role=\"switch\" id=\"flexSwitchCheckChecked\"\r\n                [checked]=\"selectMatureScheme\" (change)=\"onToggleChange()\">\r\n            </div>\r\n          </div>\r\n        </div>\r\n        <!-- <div class=\"select_matured_text  w-100 text-start cursor-pointer\"\r\n          *ngIf=\"selectMatureScheme && !selectedRedemption\" (click)=\"selectScheme()\">\r\n          Select Matured Scheme\r\n        </div> -->\r\n        <!-- <div class=\"select_matured_text d-flex flex-column gap-2 w-100 text-start cursor-pointer\"\r\n          *ngIf=\"selectedRedemption\">\r\n          Selected Scheme\r\n          <div class=\"d-flex w-100 justify-content-between align-items-center group_invest\">Group Investment\r\n            scheme-5000/M <span>Change</span></div>\r\n          <div class=\"d-flex justify-content-between align-items-center w-100 redeem_amount\">Redeemable Amount\r\n            <span>₹{{selectedRedmpationData.selectedAmount}}</span>\r\n          </div>\r\n        </div> -->\r\n      </div>\r\n      <div class=\"scheme-section\" *ngIf=\"selectMatureScheme\">\r\n        <ng-container *ngTemplateOutlet=\"SCHEME_REDEMPTION\"></ng-container>\r\n      </div>\r\n      <div class=\"coupon-section\" [id]=\"data?.id\" *ngIf=\"cartType === 'SHOPPING' && !referEarnExist\"\r\n        (click)=\"openDialog(CouponList)\">\r\n        <div class=\"coupon-left\">\r\n          <div class=\"coupon-icon\"><mat-icon>percent</mat-icon></div>\r\n          <span class=\"coupon-text\" *ngIf=\"!responseData.billdetails?.couponId\">Apply\r\n            Coupon</span>\r\n          <span class=\"coupon-text\" *ngIf=\"responseData.billdetails?.couponId\">Coupon\r\n            Applied</span>\r\n        </div>\r\n        <svg *ngIf=\"!responseData.billdetails?.couponId\" xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\"\r\n          viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"\r\n          stroke-linejoin=\"round\" class=\"chevron-icon\">\r\n          <path d=\"m9 18 6-6-6-6\" />\r\n        </svg>\r\n        <span *ngIf=\"responseData.billdetails?.couponId\"\r\n          (click)=\"removeCoupon($event)\"><mat-icon>close</mat-icon></span>\r\n      </div>\r\n\r\n      <div class=\"plan-details-container p-3 rounded-4 bg-white text-dark voucher-details\"\r\n        *ngIf=\"referEarnExist && this?.redemptionPoints?.availablePoints > 0\">\r\n        <div class=\"fs-14 fw-500\">\r\n          Rewards Available\r\n        </div>\r\n        <div class=\"d-flex justify-content-between align-items-start border-bottom pb-2\">\r\n          <div class=\"avb_pts mt-2 mb-2\">\r\n            <span class=\"fs-16 fw-500 total_points text-secondary\">\r\n              <span class=\" fs-18 fw-600 text-dark\">{{(this?.redemptionPoints?.availablePoints || 0).toFixed(2)}}</span>\r\n              pts\r\n            </span>\r\n            <div class=\"total_value fs-12 text-secondary\">\r\n              = max ₹{{(this?.redemptionPoints?.pointsConvertedRupees || 0).toFixed(2)}} discount\r\n            </div>\r\n          </div>\r\n          <div class=\"wallte_icon\">\r\n            <img src=\"https://d2z9497xp8xb12.cloudfront.net/prod-images/777779c1775200561187wallet_(1).png\" alt=\"\">\r\n          </div>\r\n        </div>\r\n        <div class=\"d-flex justify-content-between align-items-center mt-3\">\r\n          <div class=\"redemable_text\">\r\n            <div class=\"title_text\">\r\n              <div class=\"fs-14 fw-500\">\r\n                Redeem Points\r\n              </div>\r\n              <div class=\"fs-13 fs-400\">\r\n                Use your points for discount\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"toggle_btn\">\r\n            <label class=\"switch\">\r\n              <input type=\"checkbox\" id=\"toggleSwitch\" [checked]=\"isPointsRedeeming\"\r\n                (click)=\"onPointsRedeemingChange($event)\" />\r\n              <span class=\"slider\"></span>\r\n            </label>\r\n          </div>\r\n        </div>\r\n        <div class=\"mt-3 success_selected w-100 applied-coupon-card\" *ngIf=\"isPointsRedeeming\">\r\n          <div class=\"d-flex align-items-start gap-2\">\r\n            <div class=\"success_icon\">\r\n              <mat-icon class=\"d-flex justify-content-center align-items-center text-success\">check_circle</mat-icon>\r\n            </div>\r\n            <div class=\"success_text\">\r\n              <div class=\"fs-13 fw-500\">\r\n                You're saving ₹\r\n                {{totalSavingAmt || 0}}\r\n              </div>\r\n              <div class=\"fs-12 fs-400 text-success\">\r\n                {{totalSavingPoints}} points remaining after redemption\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n\r\n      <!-- Existing coupon row (keep as-is) -->\r\n      <div class=\"coupon-section d-flex flex-column voucher-details\" [id]=\"data?.id\"\r\n        *ngIf=\"cartType === 'SHOPPING' && referEarnExist\">\r\n        <div class=\"d-flex justify-content-between align-items-center w-100\">\r\n          <div class=\"coupon-left\">\r\n            Apply Coupon\r\n          </div>\r\n          <div (click)=\"addRedemptionCoupon(RedemptionVouchers)\">View All</div>\r\n        </div>\r\n\r\n        <!-- Applied Coupon Success Banner -->\r\n        <div class=\"applied-coupon-card w-100 mt-3 d-flex align-items-center justify-content-between\"\r\n          *ngIf=\"selectedVoucherId\">\r\n          <div class=\"applied-coupon-left d-flex align-items-center gap-3\">\r\n            <mat-icon class=\"success-check\">check_circle</mat-icon>\r\n            <div class=\"applied-coupon-info\">\r\n              <div class=\"applied-coupon-code\">Coupon {{ selectedVoucherCode }} applied!</div>\r\n              <div class=\"applied-coupon-saving\">You're saving\r\n                <span *ngIf=\"this.couponValueType === 'AMOUNT'\">₹ {{selectedVoucherAmount || 0}}</span>\r\n                <span *ngIf=\"this.couponValueType === 'PERCENTAGE'\"> {{selectedVoucherPercentage || 0}}%</span>\r\n              </div>\r\n\r\n            </div>\r\n          </div>\r\n          <div class=\"remove-coupon-btn fs-14 fw-500 text-secondary cursor-pointer\"\r\n            (click)=\"removeRedemptionCoupon($event)\">Remove</div>\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"delivery-section\" *ngIf=\"getUrl()\">\r\n        <div class=\"delivery-header\">\r\n          <mat-icon>gps_fixed</mat-icon>\r\n          <span *ngIf=\"cartType === 'SHOPPING'\">Delivering to</span>\r\n          <span *ngIf=\"cartType === 'TRIAL'\">Trial Location at</span>\r\n          <span class=\"pincode\">{{pincode}}</span>\r\n          <!-- <a class=\"change-link\">Change Pincode</a> -->\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"summary-section\">\r\n        <div class=\"summary-title\">Summary</div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Subtotal</span>\r\n          <span class=\"summary-value\">₹{{(responseData?.billdetails?.totalNetValue ?? 0) | number: '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING' && referEarnExist && isPointsRedeeming\">\r\n          <span class=\"summary-label\">Points Redeemed</span>\r\n          <span class=\"summary-value\">- ₹{{ totalSavingAmt || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\"\r\n          *ngIf=\"cartType === 'SHOPPING' && referEarnExist && (this.couponValueType === 'AMOUNT' && appliedVoucher)\">\r\n          <span class=\"summary-label\">Voucher Applied</span>\r\n          <span class=\"summary-value\">- ₹{{ selectedVoucherAmount || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\"\r\n          *ngIf=\"cartType === 'SHOPPING' && referEarnExist && (this.couponValueType === 'PERCENTAGE' && appliedVoucher)\">\r\n          <span class=\"summary-label\">Voucher Applied</span>\r\n          <span class=\"summary-value\">- ₹{{ percentageReduced || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Shipping</span>\r\n          <span class=\"summary-value\"\r\n            [ngClass]=\"{'savings': !responseData?.billdetails?.deliveryCharges || responseData.billdetails.deliveryCharges <= 0}\">\r\n            {{ (responseData?.billdetails?.deliveryCharges && responseData.billdetails.deliveryCharges > 0) ? ('₹' +\r\n            (responseData.billdetails.deliveryCharges | number: '1.0-2')) : 'Free' }}\r\n          </span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Estimated Tax</span>\r\n          <span class=\"summary-value\">₹{{((!responseData.billdetails?.couponId ?\r\n            responseData?.billdetails?.totalTax : responseData?.billdetails?.totalTaxAfterDiscount) ?? 0) |\r\n            number: '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row total-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Total</span>\r\n          <!-- <span class=\"summary-value\">₹{{ responseData?.totalAmount | number: '1.0-2' }}</span> -->\r\n          <span class=\"total-value\" *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{ responseData?.totalAmount |\r\n            number: '1.0-2' }}</span>\r\n\r\n          <span class=\"total-value\" *ngIf=\"isPointsRedeeming\">₹{{ (responseData?.totalAmount - (totalSavingAmt || 0)) |\r\n            number: '1.0-2' }}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (percentageReduced || 0)) | number:\r\n            '1.0-2' }}</span>\r\n        </div>\r\n\r\n        <!-- Trial Cart Summary -->\r\n        <ng-container *ngIf=\"cartType === 'TRIAL'\">\r\n          <div class=\"summary-row\">\r\n            <span class=\"summary-label\">Free Trial</span>\r\n            <span class=\"summary-value\">₹0</span>\r\n          </div>\r\n          <div class=\"summary-row\">\r\n            <span class=\"summary-label\">Service Charge</span>\r\n            <span class=\"summary-value savings\">Free</span>\r\n          </div>\r\n          <div class=\"summary-divider\"></div>\r\n          <div class=\"summary-row total-row\">\r\n            <span class=\"summary-label\">Total</span>\r\n            <span class=\"summary-value\">₹0</span>\r\n          </div>\r\n          <!-- <span class=\"total-value\" *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{ responseData?.totalAmount |\r\n            number: '1.0-2' }}</span>\r\n\r\n          <span class=\"total-value\" *ngIf=\"isPointsRedeeming\">₹{{ (responseData?.totalAmount - (totalSavingAmt || 0)) |\r\n            number: '1.0-2' }}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (percentageReduced || 0)) | number:\r\n            '1.0-2' }}</span> -->\r\n        </ng-container>\r\n      </div>\r\n      <button class=\"place-order-btn\" (click)=\"edit ? '' : proceedToListPage()\" simpoButtonDirective\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        *ngIf=\"cartType === 'SHOPPING'\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[1]?.content?.label ?? 'Continue\r\n        Shopping'}}</button>\r\n      <button class=\"place-order-btn mt-0\" (click)=\"edit ? '' : proceedToCheckout()\" simpoButtonDirective\r\n        *ngIf=\"cartType === 'SHOPPING'\" [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\"\r\n        [color]=\"data?.styles?.background?.accentColor\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[0]?.content?.label ?? 'Checkout\r\n        Cart'}}</button>\r\n      <button class=\"place-order-btn mt-0\" simpoButtonDirective *ngIf=\"cartType === 'TRIAL'\"\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\" [backgroundInfo]=\"styles?.background\" (click)=\"bookAppointment()\">BOOK\r\n        APPOINTMENT</button>\r\n\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n<ng-template #CHECKOUTPAGE>\r\n  <div class=\"checkout-left-panel\">\r\n    <div class=\"checkout-main-content\">\r\n      <!-- <div class=\"delivery-options\">\r\n        <div class=\"delivery-option active\">\r\n          <div class=\"delivery-icon\"></div>\r\n          HOME DELIVERY\r\n        </div>\r\n        <div class=\"delivery-option\">\r\n          <div class=\"delivery-icon\"></div>\r\n          STORE PICK-UP\r\n        </div>\r\n      </div> -->\r\n\r\n      <div class=\"section-title\">Shipping Address</div>\r\n\r\n      <div class=\"shipping-info\" *ngIf=\"defaultAddress\">\r\n        <div class=\"address-info\">\r\n          <div class=\"address-name\">{{defaultAddress?.receiverName}} ({{defaultAddress?.addressType}})</div>\r\n          <div class=\"address-details\">{{defaultAddress?.addressLine1}}, {{defaultAddress?.cityName}},\r\n            {{defaultAddress?.stateName}}</div>\r\n          <div class=\"mobile-number\">Mobile: {{defaultAddress?.receiverPhone}}</div>\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"addLinks h-100\" *ngIf=\"!defaultAddress\" (click)=\"addAddress()\">\r\n        <mat-icon>add</mat-icon>\r\n      </div>\r\n\r\n      <button class=\"change-address-btn\" (click)=\"changeAddress()\" *ngIf=\"defaultAddress\">CHANGE OR ADD ADDRESS</button>\r\n\r\n      <button class=\"btn w-100 mt-1 payment-btn\" (click)=\"proceedToPayment()\" simpoButtonDirective\r\n        *ngIf=\"defaultAddress && !placeOrderLoader\" [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\"\r\n        [color]=\"data?.styles?.background?.accentColor\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">\r\n        Place Order\r\n      </button>\r\n      <button class=\"btn w-100 mt-1 payment-btn\" simpoButtonDirective *ngIf=\"defaultAddress && placeOrderLoader\"\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\" [backgroundInfo]=\"styles?.background\">\r\n        Loading...\r\n      </button>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"checkout-right-panel\">\r\n    <div class=\"order-summary\">\r\n      <div class=\"summary-title\">Order Summary</div>\r\n\r\n      <div class=\"checkout-product\">\r\n        <div class=\"product-item\" *ngFor=\"let item of responseData?.orderedItems; let idx = index\">\r\n          <img [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" class=\"product-image\"\r\n            alt=\"\">\r\n          <div class=\"product-details\">\r\n            <div class=\"product-name\">{{item.itemName}}</div>\r\n            <div class=\"product-quantity\">Quantity: {{item.quantity}}</div>\r\n            <div class=\"product-price\">₹{{(item.sellingPrice * item.quantity) | number: '1.0-2'}}</div>\r\n          </div>\r\n        </div>\r\n\r\n      </div>\r\n\r\n      <div class=\"price-breakdown\">\r\n        <div class=\"price-row\">\r\n          <span>Total Price</span>\r\n          <span>₹{{(responseData?.billdetails?.totalNetValue\r\n            ?? 0) | number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row\">\r\n          <span>Total Tax</span>\r\n          <span>₹{{((!responseData.billdetails?.couponId ?\r\n            responseData?.billdetails?.totalTax : responseData?.billdetails?.totalTaxAfterDiscount) ?? 0) |\r\n            number:\r\n            '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING' && cartInfo?.billdetails?.orraSchemeRedeemedAmount\">\r\n          <span class=\"summary-label\">Redeem Amount</span>\r\n          <span class=\"summary-value\">₹{{(cartInfo?.billdetails?.orraSchemeRedeemedAmount ?? 0) | number:\r\n            '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"price-row discount\"\r\n          *ngIf=\"responseData?.billdetails?.discountAmount && subIndustryName != 'Ecommerce Jewellery'\">\r\n          <span>Coupon Discount</span>\r\n          <span>- ₹{{responseData?.billdetails?.discountAmount\r\n            | number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row\"\r\n          *ngIf=\"responseData?.billdetails?.deliveryCharges && responseData.billdetails.deliveryCharges > 0\">\r\n          <span>Delivery Charge</span>\r\n          <span>{{responseData.billdetails.deliveryCharges\r\n            |\r\n            number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row total\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span>TOTAL AMOUNT</span>\r\n          <span *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{(responseData?.totalAmount ?? 0) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"isPointsRedeeming\">₹{{(responseData?.totalAmount - (totalSavingAmt || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (responseData?.totalAmount * (selectedVoucherPercentage / 100) || 0)) | number:\r\n            '1.0-2' }}</span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #CARTITEM let-products=\"data\">\r\n  <div class=\"cart-item\" *ngFor=\"let item of products\" [style.color]=\"fontColor\">\r\n    <div class=\"item-left\">\r\n      <div class=\"item-image\">\r\n        <img class=\"item-img\" [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" alt=\"\"\r\n          (click)=\"goToProductDetails(item)\" style=\"cursor: pointer;\">\r\n      </div>\r\n      <div class=\"item-details\">\r\n        <h3 class=\"item-title\">{{item.itemName}}</h3>\r\n        <div class=\"item-subtitle\" *ngIf=\"item.itemVariant\">\r\n          <span *ngFor=\"let varient of getKeys(item.itemVariant.properties); let last = last\">\r\n            {{ item.itemVariant.properties[varient] | titlecase }}<span *ngIf=\"!last\">, </span>\r\n          </span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"item-right\">\r\n      <div class=\"quantity-control\" *ngIf=\"cartType === 'SHOPPING'\">\r\n        <button class=\"qty-btn px-2\" (click)=\"decreaseQty(item)\" [disabled]=\"item.quantity === 1\">\r\n          <mat-icon>remove</mat-icon>\r\n        </button>\r\n        <span class=\"qty-value px-3\">{{item.quantity}}</span>\r\n        <button class=\"qty-btn px-2\" (click)=\"increaseQty(item)\">\r\n          <mat-icon>add</mat-icon>\r\n        </button>\r\n      </div>\r\n\r\n      <div class=\"item-price\">\r\n        ₹{{item.sellingPrice | number: '1.0-2'}}\r\n      </div>\r\n\r\n      <div class=\"delete-btn-circle\" (click)=\"removeItem(item)\">\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"\r\n          stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"lucide lucide-trash-2\">\r\n          <path d=\"M3 6h18\" />\r\n          <path d=\"M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6\" />\r\n          <path d=\"M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2\" />\r\n          <line x1=\"10\" x2=\"10\" y1=\"11\" y2=\"17\" />\r\n          <line x1=\"14\" x2=\"14\" y1=\"11\" y2=\"17\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #EMPTYITEM>\r\n  <section class=\"empty-cart w-100 d-flex align-items-center justify-content-center\">\r\n    <div class=\"empty-cart-container d-flex flex-column\">\r\n      <div class=\"cart-image\">\r\n        <img loading=\"lazy\" onerror=\"this.src='https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\"\r\n          [src]=\"data?.content?.image?.url\" [alt]=\"data?.content?.image?.altText\" [appImageEditor]=\"edit || false\"\r\n          [imageData]=\"data?.content?.image\" [sectionId]=\"data?.id\">\r\n      </div>\r\n      <div class=\"cart-text content-side\">\r\n        <ng-container *ngFor=\"let text of data?.content?.inputText\">\r\n          <div class=\"d-flex justify-content-center\"\r\n            [ngClass]=\"{'heading-medium': text.label == 'Heading', 'description': text.label == 'Text'}\">\r\n            <simpo-text-editor [(value)]=\"text.value\" [editable]=\"edit || false\"></simpo-text-editor>\r\n          </div>\r\n        </ng-container>\r\n      </div>\r\n      <button class=\"place-order-btn mx-auto w-fit\" (click)=\"edit ? '' : proceedToListPage()\" simpoButtonDirective\r\n        [buttonStyle]=\"data?.action?.buttons?.[1]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[1]?.content?.label ?? 'Continue\r\n        Shopping'}}</button>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #SCHEME_REDEMPTION>\r\n  <div class=\"modal-body\">\r\n    <div class=\"scheme-option\" *ngFor=\"let scheme of schemeList\" (click)=\"redeemScheme(scheme, false)\"\r\n      [style.borderColor]=\"cartInfo.billdetails.orraSchemeCode ? styles?.background?.color : ''\">\r\n      <label for=\"individual\" class=\"scheme-card\">\r\n        <div class=\"scheme-info d-flex gap-1\">\r\n          <div class=\"form-check-radio\">\r\n            <input class=\"form-check-input-radio\" type=\"radio\" name=\"flexRadioDefault\" id=\"flexRadioDefault2\">\r\n          </div>\r\n          <div class=\"right-side\">\r\n            <div class=\"scheme-name\">\r\n              <div class=\"scheme-title\">Individual Investment Scheme</div>\r\n              <div class=\"scheme-monthly\">₹8000/M</div>\r\n            </div>\r\n            <div class=\"scheme-details\">\r\n              <span class=\"scheme-id\">GPP Id: {{scheme.GPPId}}</span>\r\n              <!-- <span class=\"scheme-maturity\">Maturity Date: 12 April 2024</span> -->\r\n            </div>\r\n            <div class=\"scheme-amount\">₹{{scheme.amount}}</div>\r\n          </div>\r\n        </div>\r\n      </label>\r\n    </div>\r\n    <div class=\"reedem_error d-flex justify-content-center align-items-center\" *ngIf=\"showReedemError\">\r\n      Please add more ₹{{vaildAmount}} to reedem this scheme\r\n    </div>\r\n  </div>\r\n</ng-template>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cart.component.js","sourceRoot":"","sources":["../../../../../../../projects/simpo-ui/src/lib/ecommerce/sections/cart/cart.component.ts","../../../../../../../projects/simpo-ui/src/lib/ecommerce/sections/cart/cart.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,MAAM,EAAE,KAAK,EAAqB,QAAQ,EAAe,SAAS,EAAE,MAAM,eAAe,CAAC;AAE1H,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AACzF,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,WAAW,MAAM,+BAA+B,CAAC;AAGxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAGhE,OAAO,EAAE,eAAe,EAAa,eAAe,EAAgB,MAAM,0BAA0B,CAAC;AAKrG,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,IAAI,MAAM,aAAa,CAAC;AAC/B,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAkB,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtF,OAAO,EAAkC,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAIvG,OAAO,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAC1F,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAEjF,OAAO,EAAE,0BAA0B,EAAE,MAAM,iDAAiD,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,uDAAuD,CAAC;AAC7F,OAAO,EAAE,0BAA0B,EAAE,MAAM,qEAAqE,CAAC;AACjH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAE,wBAAwB,EAAE,MAAM,gDAAgD,CAAC;AAC1F,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;AA6ChE,MAAM,OAAO,aAAc,SAAQ,WAAW;IAe5C,YACmB,aAA4B,EAC5B,WAAwB,EACxB,MAAc,EACd,WAAwB,EACxB,SAAoB,EACpB,cAAqC,EACrC,cAA8B,EAC9B,WAA2B,EAC3B,cAA8B,EACH,aAAkB,EAC3C,SAAsC;QAEzD,KAAK,EAAE,CAAC;QAZS,kBAAa,GAAb,aAAa,CAAe;QAC5B,gBAAW,GAAX,WAAW,CAAa;QACxB,WAAM,GAAN,MAAM,CAAQ;QACd,gBAAW,GAAX,WAAW,CAAa;QACxB,cAAS,GAAT,SAAS,CAAW;QACpB,mBAAc,GAAd,cAAc,CAAuB;QACrC,mBAAc,GAAd,cAAc,CAAgB;QAC9B,gBAAW,GAAX,WAAW,CAAgB;QAC3B,mBAAc,GAAd,cAAc,CAAgB;QACH,kBAAa,GAAb,aAAa,CAAK;QAC3C,cAAS,GAAT,SAAS,CAA6B;QAnB3D,cAAS,GAAY,KAAK,CAAC;QAGpB,eAAU,GAAkC,KAAK,CAAC;QACzD,aAAQ,GAAyB,UAAU,CAAA;QAqB3C,aAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;QACrB,gBAAW,GAAgB,IAAI,CAAC;QAChC,oBAAe,GAA0B,IAAI,CAAC;QAC/C,uBAAkB,GAAW,CAAC,CAAC;QAE/B,sBAAiB,GAAW,EAAE,CAAC;QAC/B,eAAU,GAAa,EAAE,CAAC;QACjC,kBAAa,GAA0B,IAAI,CAAA;QAC3C,uBAAkB,GAAY,KAAK,CAAC;QACpC,aAAQ,GAAQ;YACd,YAAY,EAAE,IAAI;YAClB,UAAU,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC;YAC7E,WAAW,EAAE;gBACX,eAAe,EAAE,CAAC;gBAClB,uBAAuB,EAAE,CAAC;gBAC1B,iBAAiB,EAAE,CAAC;gBACpB,UAAU,EAAE,CAAC;gBACb,mBAAmB,EAAE,CAAC;gBACtB,gBAAgB,EAAE,CAAC;gBACnB,iBAAiB,EAAE,CAAC;gBACpB,0BAA0B,EAAE,CAAC;gBAC7B,gBAAgB,EAAE,EAAE;aACrB;YACD,QAAQ,EAAE,KAAK;YACf,QAAQ,EAAE,MAAM;YAChB,cAAc,EAAE,IAAI;YACpB,WAAW,EAAE;gBACX,QAAQ,EAAE,EAAE;gBACZ,UAAU,EAAE,EAAE;gBACd,QAAQ,EAAE,EAAE;gBACZ,OAAO,EAAE,EAAE;aACZ;YACD,WAAW,EAAE,CAAC;SACf,CAAA;QAGD,oBAAe,GAAW,EAAE,CAAA;QAC5B,gBAAW,GAAY,KAAK,CAAC;QAC7B,uBAAkB,GAAY,KAAK,CAAC;QAuBpC,mBAAc,GAAQ;YACpB,QAAQ,EAAE,sCAAsC;YAChD,YAAY,EAAE,sCAAsC;YACpD,WAAW,EAAE,IAAI;YACjB,cAAc,EAAE;gBACd;oBACE,QAAQ,EAAE,sCAAsC;oBAChD,WAAW,EAAE,sCAAsC;oBACnD,YAAY,EAAE,sCAAsC;oBACpD,UAAU,EAAE,cAAc;oBAC1B,cAAc,EAAE,IAAI;oBACpB,QAAQ,EAAE,sDAAsD;oBAChE,aAAa,EAAE,IAAI;oBACnB,aAAa,EAAE,IAAI;oBACnB,UAAU,EAAE,CAAC;oBACb,OAAO,EAAE,OAAO;oBAChB,SAAS,EAAE,GAAG;oBACd,iBAAiB,EAAE,OAAO;oBAC1B,gBAAgB,EAAE,GAAG;oBACrB,kBAAkB,EAAE,GAAG;oBACvB,cAAc,EAAE,OAAO;oBACvB,OAAO,EAAE,GAAG;oBACZ,QAAQ,EAAE,CAAC;oBACX,QAAQ,EAAE,IAAI;oBACd,cAAc,EAAE,IAAI;iBACrB;aACF;YACD,aAAa,EAAE;gBACb,eAAe,EAAE,OAAO;gBACxB,iBAAiB,EAAE,OAAO;gBAC1B,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,OAAO;gBACrB,YAAY,EAAE;oBACZ,WAAW,EAAE,KAAK;oBAClB,WAAW,EAAE,KAAK;oBAClB,WAAW,EAAE,GAAG;iBACjB;gBACD,iBAAiB,EAAE,GAAG;gBACtB,UAAU,EAAE,IAAI;gBAChB,YAAY,EAAE,IAAI;gBAClB,gBAAgB,EAAE,GAAG;gBACrB,uBAAuB,EAAE,GAAG;gBAC5B,gBAAgB,EAAE,IAAI;gBACtB,0BAA0B,EAAE,GAAG;aAChC;YACD,UAAU,EAAE,KAAK;YACjB,gBAAgB,EAAE,IAAI;YACtB,aAAa,EAAE;gBACb,QAAQ,EAAE,sCAAsC;gBAChD,UAAU,EAAE,UAAU;gBACtB,QAAQ,EAAE,YAAY;gBACtB,OAAO,EAAE,sBAAsB;aAChC;YACD,kBAAkB,EAAE,+BAA+B;YACnD,aAAa,EAAE,OAAO;YACtB,UAAU,EAAE,MAAM;SACnB,CAAA;QAOD,eAAU,GAAU,EAAE,CAAA;QAuWtB,qBAAgB,GAAY,KAAK,CAAC;QAmLlC,oBAAe,GAAiC,IAAI,CAAC;QAuCrD,mBAAc,GAA2B,SAAS,CAAA;QAClD,yBAAoB,GAA4B,SAAS,CAAA;QAOzD,oBAAe,GAAW,EAAE,CAAA;QA8N5B,oBAAe,GAAY,KAAK,CAAC;QACjC,gBAAW,GAAW,CAAC,CAAA;QAmFvB,mBAAc,GAAY,KAAK,CAAC;QAChC,sBAAiB,GAAY,KAAK,CAAC;QAenC,mBAAc,GAAW,CAAC,CAAA;QAC1B,sBAAiB,GAAW,CAAC,CAAA;QAC7B,oBAAe,GAAW,CAAC,CAAA;QA5gCzB,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IA2CD,QAAQ;QACN,IAAI,CAAC,iBAAiB,EAAE,CAAA;QACxB,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;QACrE,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,EAAE,CAAC;YACjC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,eAAe,IAAI,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;QAClF,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,KAAU,EAAE,EAAE;YACvD,IAAI,KAAK,IAAI,KAAK,CAAC,UAAU,CAAC;gBAC5B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAChC,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,QAAiB,EAAE,EAAE;YACpE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,gBAAgB,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;QACnI,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC;QAChC,yBAAyB;IAC3B,CAAC;IA0DD,mBAAmB;QACjB,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;YAC5D,IAAI,CAAC,WAAW,GAAG,GAAG,EAAE,IAAI,CAAA;QAC9B,CAAC,CAAC,CAAA;IACJ,CAAC;IAGD,gBAAgB;QACd,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;YACzD,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,WAAW;QACT,IAAI,CAAC,mBAAmB,EAAE,WAAW,EAAE,CAAC;IAC1C,CAAC;IACD,cAAc;QAEZ,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;YAChC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC;YACnG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;YAChC,OAAO;QACT,CAAC;QACD,IAAI,CAAC,kBAAkB,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAC1B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAA;QAC9B,IAAI,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;YACzE,IAAI,OAAO,GAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,wBAAwB,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,EAAE,CAAA;YACtI,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;QAClC,CAAC;IACH,CAAC;IACD,YAAY;QACV,IAAI,IAAI,GAAgB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAA;QACrD,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC9E,IAAI,CAAC,aAAa,GAAG,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,IAAI,EAAE,CAAA;YACzD,CAAC,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;IAED,uBAAuB;QACrB,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YACnD,QAAQ,CAAC,SAAS,GAAG,CAAC,qBAA0B,EAAE,EAAE;gBAClD,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC;YAC3D,CAAC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,cAAc;QACZ,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC;QAEnF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAU,CAAC;QACzD,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG;YAC1B,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM;YAClC,UAAU,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI;YAC1C,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,MAAM;YAC1C,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,KAAK;SACzC,CAAA;QACD,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YACzF,MAAM,YAAY,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,IAAI,EAAE,CAAC;YAC7D,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YAC3D,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;YACrD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,0BAA0B,CAAC,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,wBAAwB,CAAA;YAClH,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,gBAAgB,CAAC,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,cAAc,CAAA;YAC9F,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;YAC/G,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,cAAc;gBACjD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAA;YAChC,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,CAAC,EAAE,CAAC;gBACjD,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;gBACnC,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,UAAU,GAAG,GAAG,EAAE;oBAErF,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;wBACtD,YAAY,CAAC,SAAS,GAAG,CAAC,QAAa,EAAE,EAAE;4BACzC,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC;gCAClG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;4BACxE,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,MAAM,CAAC;gCACtG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;4BAC5E,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;4BAC7E,YAAY,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;gCAClC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;gCAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;gCACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;gCAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;gCAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;gCAE9B,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAmC,CAAC;gCAC3E,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;oCACpC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;oCACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;gCAC9E,CAAC,CAAC,CAAA;gCACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;gCACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gCAC1G,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;gCAClD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC;gCAC5F,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;gCAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;gCAC7J,uEAAuE;gCACvE,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;4BACpC,CAAC,CAAC,CAAA;wBACJ,CAAC,CAAA;wBACD,YAAY,CAAC,OAAO,GAAG,CAAC,QAAa,EAAE,EAAE;4BACvC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;wBAC5G,CAAC,CAAA;oBACH,CAAC,CAAC,CAAA;gBACJ,CAAC,CAAA;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;oBACtD,YAAY,CAAC,SAAS,GAAG,CAAC,QAAa,EAAE,EAAE;wBAEzC,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAmC,CAAC;wBAC3E,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;wBAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;wBACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,CAAC,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;wBACnG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;wBAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;wBAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;wBAE9B,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;4BACpC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;4BACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;wBAC9E,CAAC,CAAC,CAAA;wBACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;wBACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;wBAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;wBAC7J,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;wBAClD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;wBAClC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;4BAC1E,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;4BACtD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;4BAChD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;wBACxD,CAAC,CAAC,CAAA;oBACJ,CAAC,CAAA;gBACH,CAAC,CAAC,CAAA;YACJ,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,iBAAiB;QACf,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC;YAC1D,OAAO;QAET,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,WAAW,EAAE,kBAAkB,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACrH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC;YAClD,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAC;YAC/D,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,kBAAkB,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,IAAI,YAAY;QACd,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAiB,CAAC;IACnD,CAAC;IAED,eAAe,CAAC,WAAkB;QAChC,KAAK,IAAI,OAAO,IAAI,WAAW,EAAE,CAAC;YAChC,IAAI,SAAS,GAAG,KAAK,CAAC;YACtB,KAAK,IAAI,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;gBAChD,IAAI,QAAQ,CAAC,SAAS,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC;oBAC7C,SAAS,GAAG,IAAI,CAAC;oBACjB,wCAAwC;gBAC1C,CAAC;YACH,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED,aAAa;QACX,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC;YACvH,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACxD,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YACxF,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE;gBAC3F,OAAO;oBACL,YAAY,EAAE,MAAM,CAAC,QAAQ;oBAC7B,YAAY,EAAE,MAAM,CAAC,WAAW;oBAChC,mBAAmB,EAAE,MAAM,CAAC,iBAAiB;oBAC7C,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,SAAS,EAAE,MAAM,CAAC,SAAS;iBAC5B,CAAA;YACH,CAAC,CAAC,CAAC;QAEL,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,YAAY,CAAC,KAAiB;QAC5B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,GAAG,EAAE,CAAC;QAC1C,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;QAC7E,YAAY,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;YAElC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC7B,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;YACpC,YAAY,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;YACtC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;YAC5F,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,CAAC,CAAC;YAC7C,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC;QAChC,CAAC,CAAC,CAAA;QACF,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE;YACtD,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC;YACnF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;YAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;YACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;YAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;YAE9C,YAAY,CAAC,SAAS,GAAG,CAAC,QAAa,EAAE,EAAE;gBACzC,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAmC,CAAC;gBAC3E,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;oBACpC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;oBACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC9E,CAAC,CAAC,CAAA;gBAEF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,CAAC,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;gBACnG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;gBACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;gBAC7J,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;gBAClD,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE;oBAC/B,IAAI,CAAC,cAAc,EAAE,CAAC;gBAExB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;YACpC,CAAC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,iBAAiB;QACf,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE,CAAC;YAClC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,IAAI,CAAC,iBAAiB,EAAE,CAAA;YACxB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAClB,QAAQ,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;gBAC5B,QAAQ,CAAC,eAAe,CAAC,SAAS,GAAG,CAAC,CAAC;YACzC,CAAC;QAEH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,0CAA0C,EAAE,CAAC,CAAC;YACpH,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,KAAgC;QAC7C,IAAI,CAAC,KAAK;YACR,OAAO,IAAI,CAAC;QAEd,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,YAAY,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAE/C,OAAO,IAAI;aACR,WAAW,EAAE;aACb,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;aACnB,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC3B,CAAC;IAED,kBAAkB,CAAC,OAAqB;QACtC,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI;YACP,OAAO;QAET,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,iBAAiB;QACf,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,CAAC;IACD,UAAU,CAAC,IAAkB;QAE3B,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,EAAE,SAAS;YACf,IAAI,EAAE,gCAAgC,GAAG,IAAI,CAAC,QAAQ,GAAG,qDAAqD;YAC9G,iBAAiB,EAAE,kBAAkB;YACrC,cAAc,EAAE,IAAI;YACpB,eAAe,EAAE,IAAI;YACrB,cAAc,EAAE,aAAa;YAC7B,eAAe,EAAE,WAAW;YAC5B,iBAAiB,EAAE,KAAK;SACzB,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YACnB,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;oBACjC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAChC,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;gBAC5B,CAAC;gBACD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC;iBAAM,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;gBAC7B,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;oBACjC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAChC,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAA;gBAC5B,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IACO,kBAAkB,CAAC,IAAkB;QAC3C,IAAI,CAAC,WAAW,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IACO,kBAAkB,CAAC,IAAkB;QAC3C,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;QAClB,IAAI,IAAI,CAAC,eAAe;YACtB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,OAAY,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5G,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;QAClD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YACxF,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC;YACnF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;YAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;YACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;YAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC;YAC5F,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;YAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;YAC9C,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC;YAClE,IAAI,CAAC,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC;YAE9D,QAAQ,EAAE,IAAI,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAS,EAAE,EAAE;gBACjD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;gBACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9E,CAAC,CAAC,CAAA;YACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;YACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;YAC7J,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;QACpD,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,SAAS,CAAC,IAAkB,EAAE,QAAgB;QAC5C,uBAAuB;QACvB,wBAAwB;QACxB,IAAI;QACJ,SAAS;QACT,wBAAwB;QACxB,IAAI;QACJ,IAAI,CAAC,eAAe,GAAG,KAAK,CAAA;QAC5B,2BAA2B;QAC3B,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;gBACxF,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC;gBACnF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;gBAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;gBACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;gBAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;gBAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;gBAC9B,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;gBAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC;gBAE5F,QAAQ,EAAE,IAAI,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC,IAAS,EAAE,EAAE;oBACjD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;oBACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC9E,CAAC,CAAC,CAAA;gBACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;gBACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;gBAC7J,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;YACpD,CAAC,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;IAGD,KAAK,CAAC,gBAAgB;QACpB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,MAAM,GAAQ,EAAE,CAAC;QAErB,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,kBAAkB,EAAE,CAAC;YACzD,MAAM,eAAe,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAE3D,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC/D,MAAM;oBACJ,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,IAAS,EAAE,EAAE,CAChD,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,cAAc,CAAC;wBACnC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CACjD,IAAI,EAAE,CAAC;YACZ,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,8BAA8B,EAAE,KAAK,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE,CAAC;YACnC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,0CAA0C,EAAE,CAAC,CAAC;YACpH,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,uBAAuB,GAAG,YAAY,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,yBAAyB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QACnJ,MAAM,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAE/I,IAAI,uBAAuB,IAAI,CAAC,UAAU,EAAE,CAAC;YAC3C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,2BAA2B,EAAE,CAAC,CAAC;YACnH,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAU,CAAC;QACzD,MAAM,OAAO,GAAG,UAAU,EAAE,kBAAkB,CAAC,IAAI,CAAC,kBAAkB,CAAY,CAAC;QACnF,IAAI,OAAO,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,gCAAgC,EAAE,CAAC,CAAC;YACrH,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC;YAC9F,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;aACtD,CAAC;YACJ,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,gCAAgC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5H,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;gBACnF,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACtD,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACpC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;YAClD,CAAC,CAAC,CAAA;QACJ,CAAC;QACD,IAAI,IAAI,EAAE,iBAAiB,KAAK,IAAI,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,EAAE,gBAAgB,EAAE,qBAAqB,KAAK,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,gBAAgB,EAAE,qBAAqB,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,EAAE,CAAC;gBAC3K,IAAI,CAAC,yBAAyB,EAAE,CAAA;gBAChC,OAAO;YACT,CAAC;QACH,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC;QAC1C,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;QACpF,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,UAAU,EAAE,MAAM;YAC5B,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC;YACxC,wCAAwC;YACxC,+FAA+F;YAC/F,+LAA+L;YAC/L,aAAa,EAAE,IAAI,CAAC,iBAAiB;gBACnC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBAC1F,CAAC,CAAC,IAAI,CAAC,eAAe,KAAK,QAAQ;oBACjC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,qBAAqB,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBACjG,CAAC,CAAC,IAAI,CAAC,eAAe,KAAK,YAAY;wBACrC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,iBAAiB,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;wBAC7F,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAChE,yBAAyB,EAAE,uBAAuB;YAClD,gBAAgB,EAAE;gBAChB,MAAM,EAAE,OAAO,EAAE,YAAY;gBAC7B,QAAQ,EAAE,OAAO,EAAE,aAAa;gBAChC,aAAa,EAAE,IAAI;gBACnB,OAAO,EAAE,OAAO,EAAE,aAAa;aAChC;YACD,mBAAmB,EAAE,UAAU;YAC/B,aAAa,EAAE,IAAI,EAAE,WAAW;YAChC,YAAY,EAAE,MAAM,EAAE,gBAAgB;YACtC,YAAY,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;YACjG,YAAY,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC3D,oBAAoB,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACvE,cAAc,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;YAC7H,WAAW,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI;YACjE,aAAa,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE;SACpE,CAAA;QACD,uBAAuB;QACvB,SAAS;QACT,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,cAAmB,EAAE,EAAE;YAC7E,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBACtD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAChC,CAAC;iBACI,CAAC;gBAEJ,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;gBACnC,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;gBAClC,YAAY,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;gBACtC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,CAAC;oBACR,IAAI,EAAE,SAAS;oBACf,KAAK,EAAE,QAAQ;oBACf,IAAI,EAAE,2BAA2B;oBACjC,iBAAiB,EAAE,aAAa;iBACjC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;oBACnB,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;wBACzB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACrC,CAAC;gBACH,CAAC,CAAC,CAAA;gBACF,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAChC,CAAC;QACH,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE;YACX,IAAI,KAAK,EAAE,KAAK,EAAE,IAAI,IAAI,GAAG,EAAE,CAAC;gBAC9B,IAAI,CAAC,IAAI,CAAC;oBACR,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,GAAG,MAAM;oBAC1E,eAAe,EAAE,IAAI;iBACtB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;oBACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,gCAAgC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;oBAC3H,MAAM,MAAM,GAAG,YAAY,CAAC;oBAC5B,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;oBAC3C,IAAI,UAAU,GAAmB,IAAI,CAAC;oBACtC,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;wBACrG,UAAU,GAAG,QAAQ,CAAC,CAAC,CAAY,CAAC;oBACtC,CAAC,CAAC,CAAA;oBACF,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;wBACzB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAkB,EAAE,EAAE;4BACxD,IAAI,IAAI,CAAC,MAAM,IAAI,UAAU,EAAE,MAAM;gCACnC,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC;wBAC3D,CAAC,CAAC,CAAA;wBACF,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;wBACrF,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;oBACzG,CAAC;yBAAM,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;wBAChC,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,IAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,IAAI,UAAU,EAAE,MAAM,CAAC,CAAC;wBAC1H,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;wBACrF,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;wBACvG,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBAC1B,CAAC;gBACH,CAAC,CAAC,CAAA;YACJ,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAAC;YACzG,CAAC;YACD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAChC,CAAC,CAAC,CAAA;IACJ,CAAC;IAGD,eAAe,CAAC,KAAa;QAC3B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IAED,gBAAgB,CAAC,OAAqB;QACpC,OAAO,KAAK,CAAC,CAAC,iBAAiB;IACjC,CAAC;IACD,OAAO,CAAC,MAAc;QACpB,IAAI,MAAM;YACR,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC7B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,WAAW;QAET,IAAI,MAAM,CAAC,UAAU,IAAI,GAAG;YAC1B,OAAO;QAET,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjD,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC,EAAE,GAAG,CAAC,CAAC;IACV,CAAC;IACD,WAAW;QACT,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACzB,CAAC;IAED,UAAU,CAAC,SAAc;QAEvB,IAAI,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ;YACtC,OAAO;QAET,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,WAAW,IAAI,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC;YACvH,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAExD,gCAAgC;QAChC,oIAAoI;QACpI,YAAY;QACZ,IAAI;QAEJ,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YACxF,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE;gBAC3F,OAAO;oBACL,YAAY,EAAE,MAAM,CAAC,QAAQ;oBAC7B,YAAY,EAAE,MAAM,CAAC,WAAW;oBAChC,mBAAmB,EAAE,MAAM,CAAC,iBAAiB;oBAC7C,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,SAAS,EAAE,MAAM,CAAC,SAAS;iBAC5B,CAAA;YACH,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC7B,0BAA0B;YAC1B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC,CAAC;YACzF,SAAS;YACT,8HAA8H;YAC9H,IAAI;QACN,CAAC,CAAC,CAAA;IACJ,CAAC;IAaD,mBAAmB,CAAC,SAAc;QAChC,IAAI,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QAClF,MAAM,WAAW,GAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAW,CAAC;QAC5D,IAAI,MAAM,GAAG,WAAW,EAAE,MAAM,CAAA;QAChC,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,aAAa,CAAA;QAC9D,2DAA2D;QAC3D,wDAAwD;QACxD,kEAAkE;QAElE,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,kBAAkB,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC,SAAS,CAAC;YACpG,IAAI,EAAE,CAAC,GAAQ,EAAE,EAAE;gBACjB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBAChB,IAAI,CAAC,qBAAqB,GAAG,GAAG,CAAC;YACnC,CAAC;YACD,KAAK,EAAE,CAAC,GAAQ,EAAE,EAAE;gBAClB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC,CAAC;YAC9G,CAAC;SACF,CAAC,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YACxF,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE;gBAC3F,OAAO;oBACL,YAAY,EAAE,MAAM,CAAC,QAAQ;oBAC7B,YAAY,EAAE,MAAM,CAAC,WAAW;oBAChC,mBAAmB,EAAE,MAAM,CAAC,iBAAiB;oBAC7C,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,UAAU,EAAE,MAAM,CAAC,UAAU;oBAC7B,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,SAAS,EAAE,MAAM,CAAC,SAAS;iBAC5B,CAAA;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAA;QACF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC3F,CAAC;IAED,qBAAqB,CAAC,OAAY;QAChC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,EAAE,MAAM,EAAE,yDAAyD,EAAE,CAAC,CAAC;YACnJ,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;QAC9B,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,QAAQ,CAAC;QAC1C,IAAI,CAAC,mBAAmB,GAAG,OAAO,CAAC,WAAW,CAAC;QAC/C,IAAI,CAAC,yBAAyB,GAAG,OAAO,CAAC,WAAW,CAAA;QAEpD,IAAI,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;QACxD,IAAI,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAC7D,IAAI,GAAG,GAAG,KAAK,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,CAAC;QAErC,IAAI,OAAO,CAAC,eAAe,KAAK,YAAY,EAAE,CAAC;YAC7C,IAAI,CAAC,eAAe,GAAG,YAAY,CAAA;YACnC,IAAI,GAAG,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;gBACtC,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAA;YACtD,CAAC;iBACI,CAAC;gBACJ,IAAI,CAAC,iBAAiB,GAAG,GAAG,CAAA;YAC9B,CAAC;QACH,CAAC;aACI,CAAC;YACJ,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAA;YAC/B,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC;QACnD,CAAC;QAED,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,EAAE,SAAS;YACf,KAAK,EAAE,aAAa,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,kBAAkB;YAChN,IAAI,EAAE,eAAe,IAAI,CAAC,mBAAmB,gCAAgC;YAC7E,iBAAiB,EAAE,MAAM;YACzB,kBAAkB,EAAE,MAAM;SAC3B,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;YACd,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC;gBACvC,eAAe;YACjB,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,sBAAsB,CAAC,KAAa;QAClC,KAAK,EAAE,eAAe,EAAE,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACpC,CAAC;IAED,kBAAkB,KAAK,CAAC;IACxB,cAAc;QACZ,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC;IAChC,CAAC;IACD,WAAW,CAAC,MAAc;QAExB,IAAI,CAAC,MAAM,CAAC,UAAU;YACpB,OAAO;QAET,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACzD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QACrD,MAAM,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC;QAC7E,YAAY,CAAC,IAAI,CAAC,CAAC,QAAa,EAAE,EAAE;YAElC,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;YAClD,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;YACtD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAE7B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;YAC9F,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC;YAC5F,IAAI,CAAC,eAAe,EAAE,KAAK,EAAE,CAAC;QAChC,CAAC,CAAC,CAAA;IACJ,CAAC;IACD,aAAa,CAAC,QAAa;QACzB,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,CAAC;QACnF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,qBAAqB,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC;QAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC;QAC5F,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,CAAC,CAAC;QAE9B,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAEzB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACpC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC;gBACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9E,CAAC,CAAC,CAAA;YACF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,EAAE,eAAe,IAAI,CAAC,CAAC,CAAC;YACtK,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;YAC1G,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,CAAC;YAC7J,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,eAAe,CAAC;QACpD,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED,YAAY;QACV,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,qBAAqB,IAAI,CAAC,CAAC,CAAC;IACpJ,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,MAAM,CAAC,UAAU,IAAI,GAAG,CAAC;IAClC,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,kBAAkB,CAAC,QAAQ,CAAC;IACrC,CAAC;IAED,aAAa;QACX,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;YAC5J,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAU,CAAC;YACzD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,UAAU;QACR,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,CAAC,iBAAiB,EAAE,eAAe,CAAC,EAAE,IAAI,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;YAC5L,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAU,CAAC;YACzD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,MAAM,CAAC,CAAa;QAClB,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC;QAChC,MAAM,KAAK,GAAG,CAAC,CAAC,SAAS,KAAK,CAAC,CAAC;QAChC,MAAM,QAAQ,GAAG,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,CAAC;QAChE,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;YAC1D,OAAO;QACT,CAAC;QACD,CAAC,CAAC,cAAc,EAAE,CAAC;QACnB,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;IACnG,CAAC;IAED,YAAY;QACV,IAAI,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC,CAAC;QAC/D,MAAM,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,CAAC,QAAa,EAAE,EAAE;YAC/C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,sBAAsB,GAAG,QAAQ,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC;IACD,iBAAiB,CAAC,KAAU;QAC1B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,UAAU,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;IACnI,CAAC;IACD,WAAW,CAAC,KAAa;QACvB,OAAO,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC;IACrD,CAAC;IACD,cAAc,CAAC,KAAa;QAC1B,OAAO,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACnD,CAAC;IAED,cAAc,CAAC,QAAa,EAAE,IAAkB;QAC9C,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED,eAAe,CAAC,IAAkB;QAChC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,OAAqB,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QAEtH,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAA;QAC1C,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,OAAO,GAA8B,IAAI,yBAAyB,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;YACzG,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAClE,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;YAC7G,CAAC,CAAC,CAAA;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,CAAC,0BAA0B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC9D,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC;QAC7G,CAAC;IACH,CAAC;IAED,eAAe;QACb,MAAM,IAAI,GAAgB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,yCAAyC,EAAE,CAAC,CAAC;YACnH,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;YACvE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAA;IAC7C,CAAC;IAGD,YAAY,CAAC,MAAW,EAAE,MAAe;QACvC,IAAI,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,cAAc,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;YACpH,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,+CAA+C,EAAE,CAAC,CAAC;YAClI,OAAO;QACT,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE;YACzF,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,wBAAwB,GAAG,MAAM,CAAC,MAAM,CAAA;YAClE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,cAAc,GAAG,MAAM,CAAC,KAAK,CAAA;QACzD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,MAAM;QACJ,OAAO,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,IAAI,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IACtG,CAAC;IACD,IAAI,SAAS;QACX,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC;QACjD,IAAI,CAAC,KAAK;YAAE,OAAO,MAAM,CAAC;QAE1B,uCAAuC;QACvC,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACvD,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAED,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAE/B,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9C,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9C,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAE9C,MAAM,UAAU,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC;QAExD,OAAO,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;IAC5C,CAAC;IACD,IAAI,gBAAgB;QAClB,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC;QAEnC,IAAI,CAAC,EAAE;YAAE,OAAO,EAAE,CAAC;QAEnB,IAAI,EAAE,CAAC,oBAAoB,KAAK,OAAO,EAAE,CAAC;YACxC,OAAO,EAAE,CAAC,WAAW,CAAC;QACxB,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC;QAE9D,OAAO,KAAK;YACV,CAAC,CAAC,mBAAmB,KAAK,KAAK,EAAE,CAAC,WAAW,KAAK,EAAE,CAAC,oBAAoB,GAAG;YAC5E,CAAC,CAAC,mBAAmB,EAAE,CAAC,WAAW,KAAK,EAAE,CAAC,oBAAoB,GAAG,CAAC;IACvE,CAAC;IACD,oBAAoB,CAAC,SAA6B;QAChD,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,MAAM;gBACT,OAAO,EAAE,CAAC,CAAC,yCAAyC;YAEtD,KAAK,OAAO;gBACV,OAAO,OAAO,CAAC;YAEjB,KAAK,gBAAgB;gBACnB,OAAO,OAAO,CAAC;YAEjB,KAAK,eAAe;gBAClB,OAAO,QAAQ,CAAC;YAElB;gBACE,OAAO,EAAE,CAAC,CAAC,WAAW;QAC1B,CAAC;IACH,CAAC;IACD,WAAW,CAAC,IAAS;QACnB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAED,WAAW,CAAC,IAAS;QACnB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,CAAC;IACH,CAAC;IAKD,iBAAiB;QACf,IAAI,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QAClF,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC,SAAS,CAAC;YACzE,IAAI,EAAE,CAAC,GAAQ,EAAE,EAAE;gBACjB,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,IAAI,CAAA;gBAC9B,IAAI,CAAC,eAAe,EAAE,CAAA;YACxB,CAAC;YACD,KAAK,EAAE,CAAC,GAAQ,EAAE,EAAE;YAEpB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;IAMD,eAAe;QACb,IAAI,UAAU,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAA;QAClF,MAAM,WAAW,GAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAW,CAAC;QAC5D,IAAI,MAAM,GAAG,WAAW,EAAE,MAAM,CAAA;QAChC,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,aAAa,CAAA;QAC9D,0DAA0D;QAC1D,sDAAsD;QACtD,iEAAiE;QAEjE,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,kBAAkB,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC;YACnG,IAAI,EAAE,CAAC,GAAQ,EAAE,EAAE;gBACjB,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAA;gBAC3B,IAAI,CAAC,eAAe,GAAG,GAAG,CAAC,eAAe,GAAG,GAAG,CAAC,qBAAqB,CAAC;gBACvE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAA;gBAC7C,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAA;gBAChD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,eAAe,CAAC;YACnE,CAAC;YACD,KAAK,EAAE,CAAC,GAAQ,EAAE,EAAE;YAEpB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;IAED,uBAAuB,CAAC,KAAY;QAClC,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACtB,QAAQ,EAAE,MAAM;gBAChB,OAAO,EAAE,eAAe;gBACxB,MAAM,EAAE,+FAA+F;aACxG,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,iBAAiB,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC;QACnD,CAAC;IACH,CAAC;IAED,iBAAiB;IACjB,IAAI,kBAAkB;QACpB,OAAO,IAAI,EAAE,YAAY,EAAE,WAAW,GAAG,IAAI,EAAE,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,gBAAgB,CAAC,eAAe,GAAG,IAAI,EAAE,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC,eAAe,CAAC,CAAA;IAC/L,CAAC;IAED,IAAI,kBAAkB;QACpB,OAAO,IAAI,EAAE,YAAY,EAAE,WAAW,GAAG,IAAI,EAAE,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAC,IAAI,EAAE,gBAAgB,EAAE,qBAAqB,CAAC,CAAC,CAAC,IAAI,EAAE,YAAY,EAAE,WAAW,CAAA;IAC1K,CAAC;IAED,yBAAyB;QACvB,IAAI,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;QAC3C,IAAI,OAAO,GAAG;YACZ,UAAU,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;YAC/F,UAAU,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACzD,kBAAkB,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACrE,YAAY,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;YAC3H,SAAS,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI;YAC/D,WAAW,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE;SAClE,CAAA;QACD,IAAI,CAAC,WAAW,CAAC,yBAAyB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC;YACpE,IAAI,EAAE,CAAC,GAAQ,EAAE,EAAE;gBACjB,YAAY,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;gBACnC,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;gBAClC,YAAY,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;gBACtC,IAAI,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,CAAC;oBACR,IAAI,EAAE,SAAS;oBACf,KAAK,EAAE,QAAQ;oBACf,IAAI,EAAE,2BAA2B;oBACjC,iBAAiB,EAAE,aAAa;iBACjC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;oBACnB,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;wBACzB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;oBACrC,CAAC;gBACH,CAAC,CAAC,CAAA;YACJ,CAAC;YACD,KAAK,EAAE,CAAC,GAAQ,EAAE,EAAE;gBAClB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC;YAC3G,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;+GAvnCU,aAAa,mRAyBF,eAAe;mGAzB1B,aAAa,6LAJb,CAAC,cAAc,CAAC,2IClF7B,6t3CAo1Bc,s70BDzxBV,WAAW,8BACX,YAAY,+zBACZ,OAAO,0IACP,eAAe,8BACf,oBAAoB,shBAEpB,oBAAoB;gBACpB,WAAW;gBACX,wBAAwB,sIACxB,kBAAkB,yFAClB,mBAAmB,mFACnB,cAAc,+EAEd,WAAW,yWACX,mBAAmB,qJACnB,oBAAoB,2IACpB,0BAA0B,0GAE1B,aAAa,+BACb,qBAAqB;;4FAQZ,aAAa;kBA/BzB,SAAS;+BACE,YAAY,cACV,IAAI,WACP;wBACP,WAAW;wBACX,YAAY;wBACZ,OAAO;wBACP,eAAe;wBACf,oBAAoB;wBACpB,mBAAmB;wBACnB,oBAAoB;wBACpB,WAAW;wBACX,wBAAwB;wBACxB,kBAAkB;wBAClB,mBAAmB;wBACnB,cAAc;wBACd,gBAAgB;wBAChB,WAAW;wBACX,mBAAmB;wBACnB,oBAAoB;wBACpB,0BAA0B;wBAC1B,oBAAoB;wBACpB,aAAa;wBACb,qBAAqB;wBACrB,cAAc;wBACd,UAAU;qBACX,aACU,CAAC,cAAc,CAAC;;0BA6BxB,QAAQ;;0BAAI,MAAM;2BAAC,eAAe;;0BAClC,QAAQ;yCAzBF,IAAI;sBAAZ,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBAMW,EAAE;sBAAlB,SAAS;uBAAC,IAAI","sourcesContent":["import { Component, ElementRef, Inject, Input, OnDestroy, OnInit, Optional, TemplateRef, ViewChild } from '@angular/core';\r\nimport { Address, CartSectionModal, CartSectionStylesModel } from './cart.modal';\r\nimport { ToastModule } from 'primeng/toast';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { CommonModule } from '@angular/common';\r\nimport { ButtonDirectiveDirective } from '../../../directive/button-directive.directive';\r\nimport { MatIcon, MatIconModule } from '@angular/material/icon';\r\nimport { AnimationDirective } from '../../../directive/animation-directive';\r\nimport { HoverDirective } from '../../../directive/hover-element-directive';\r\nimport { ContentFitDirective } from '../../../directive/content-fit-directive';\r\nimport { SimpoComponentModule } from '../../../components/index';\r\nimport BaseSection from '../../../sections/BaseSection';\r\nimport { EventsService } from '.././../../services/events.service';\r\nimport { CartService } from '../../../services/cart.service';\r\nimport { AddressComponent } from \"../address/address.component\";\r\nimport { ActivatedRoute, Router } from '@angular/router';\r\nimport { AuthenticateUserComponent } from '../authenticate-user/authenticate-user.component';\r\nimport { MAT_DIALOG_DATA, MatDialog, MatDialogModule, MatDialogRef } from '@angular/material/dialog';\r\nimport { RestService } from \"../../../services/rest.service\";\r\nimport { StorageServiceService } from '../../../services/storage.service';\r\nimport { AddressDetails, User } from '../../styles/user.modal';\r\nimport { OrderedItems } from '../../styles/OrderedItems.modal';\r\nimport { BUSINESS_CONSTANTS } from '../../../constants/business.constant';\r\nimport { MessageService } from 'primeng/api';\r\nimport Swal from 'sweetalert2';\r\nimport { BackgroundDirective } from '../../../directive/background-directive';\r\nimport { MatBottomSheet, MatBottomSheetModule } from '@angular/material/bottom-sheet';\r\nimport { checkItemAlreadyAdded, Product, syncItemToServerDBRequest } from '../../styles/product.modal';\r\nimport { CustomerReviewComponent } from '../customer-review/customer-review.component';\r\nimport { merge, Subscription } from 'rxjs';\r\nimport { response } from 'express';\r\nimport { TextEditorComponent } from '../../../elements/text-editor/text-editor.component';\r\nimport { ImageEditorDirective } from '../../../directive/image-editor.directive';\r\nimport { LayOutModel } from '../../../styles/style.model';\r\nimport { SpacingHorizontalDirective } from '../../../directive/spacing-horizontal.directive';\r\nimport { AddressListComponent } from '../../../elements/address-list/address-list.component';\r\nimport { ScheduleVideoCallComponent } from '../../../elements/schedule-video-call/schedule-video-call.component';\r\nimport { ButtonEditorDirective } from '../../../directive/button-editor.directive';\r\nimport { SchemeSelectionComponent } from '../scheme-selection/scheme-selection.component';\r\nimport { ColorDirective } from '../../../directive/color.directive';\r\nimport { Unary } from '@angular/compiler';\r\nimport { MatSpinner } from '@angular/material/progress-spinner';\r\n\r\ninterface Coupon {\r\n  discountType: string;\r\n  discountName: string;\r\n  discountDescription: string;\r\n  applicable: boolean;\r\n  couponCode: string;\r\n  couponId: string;\r\n  status: boolean;\r\n  validFrom: Date;\r\n  validTo: Date;\r\n}\r\n\r\n@Component({\r\n  selector: 'simpo-cart',\r\n  standalone: true,\r\n  imports: [\r\n    FormsModule,\r\n    CommonModule,\r\n    MatIcon,\r\n    MatDialogModule,\r\n    SimpoComponentModule,\r\n    BackgroundDirective,\r\n    MatBottomSheetModule,\r\n    //DIRECTIVE\r\n    ButtonDirectiveDirective,\r\n    AnimationDirective,\r\n    ContentFitDirective,\r\n    HoverDirective,\r\n    AddressComponent,\r\n    ToastModule,\r\n    TextEditorComponent,\r\n    ImageEditorDirective,\r\n    SpacingHorizontalDirective,\r\n    AddressListComponent,\r\n    MatIconModule,\r\n    ButtonEditorDirective,\r\n    ColorDirective,\r\n    MatSpinner\r\n  ],\r\n  providers: [MessageService],\r\n  templateUrl: './cart.component.html',\r\n  styleUrl: './cart.component.css'\r\n})\r\nexport class CartComponent extends BaseSection implements OnInit, OnDestroy {\r\n  @Input() data?: CartSectionModal;\r\n  @Input() responseData?: any;\r\n  @Input() index?: number;\r\n  @Input() edit?: boolean;\r\n  @Input() delete?: boolean;\r\n  @Input() customClass?: string;\r\n  isLoading: boolean = false;\r\n\r\n  styles?: CartSectionStylesModel;\r\n  public currentTab: 'BAG' | 'ADDRESS' | 'PAYMENT' = \"BAG\";\r\n  cartType: 'SHOPPING' | 'TRIAL' = \"SHOPPING\"\r\n  @ViewChild('d2') d2!: ElementRef;\r\n\r\n  pincode: any;\r\n  constructor(\r\n    private readonly _eventService: EventsService,\r\n    private readonly cartService: CartService,\r\n    private readonly router: Router,\r\n    private readonly restService: RestService,\r\n    private readonly matDialog: MatDialog,\r\n    private readonly storageService: StorageServiceService,\r\n    private readonly messageService: MessageService,\r\n    private readonly bottomSheet: MatBottomSheet,\r\n    private readonly activatedRoute: ActivatedRoute,\r\n    @Optional() @Inject(MAT_DIALOG_DATA) public matDialogData: any,\r\n    @Optional() public dialogRef: MatDialogRef<CartComponent>\r\n  ) {\r\n    super();\r\n    this.pincode = localStorage.getItem('pincode');\r\n  }\r\n\r\n  quantity = [1, 2, 3, 4, 5, 6]\r\n  private userDetails: User | null = null;\r\n  private USER_CART_ITEMS: OrderedItems[] | null = null;\r\n  public selectedAddressIdx: number = 0;\r\n  public defaultAddress?: AddressDetails;\r\n  public enteredCouponCode: string = \"\";\r\n  public couponList: Coupon[] = [];\r\n  trialCartItem: OrderedItems[] | null = null\r\n  selectMatureScheme: boolean = false;\r\n  cartInfo: any = {\r\n    orderedItems: null,\r\n    businessId: localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\"),\r\n    billdetails: {\r\n      \"totalNetValue\": 0,\r\n      \"totalTaxAfterDiscount\": 0,\r\n      \"totalGrossValue\": 0,\r\n      \"totalTax\": 0,\r\n      \"totalOfferedValue\": 0,\r\n      \"discountAmount\": 0,\r\n      \"deliveryCharges\": 0,\r\n      \"orraSchemeRedeemedAmount\": 0,\r\n      \"orraSchemeCode\": \"\"\r\n    },\r\n    platform: \"WEB\",\r\n    cartType: \"CART\",\r\n    addressDetails: null,\r\n    userDetails: {\r\n      \"userId\": \"\",\r\n      \"userName\": \"\",\r\n      \"mobile\": \"\",\r\n      \"email\": \"\"\r\n    },\r\n    totalAmount: 0\r\n  }\r\n\r\n  loadingSubscription?: Subscription;\r\n  subIndustryName: string = ''\r\n  isJewellery: boolean = false;\r\n  selectedRedemption: boolean = false;\r\n  ecomConfigs: any;\r\n\r\n  ngOnInit() {\r\n    this.checkAppInstalled()\r\n    this.subIndustryName = localStorage.getItem('subIndustryName') ?? \"\";\r\n    if (this.subIndustryName != null) {\r\n      this.isJewellery = this.subIndustryName == 'Ecommerce Jewellery' ? true : false;\r\n    }\r\n    this.activatedRoute.queryParams.subscribe((param: any) => {\r\n      if (param && param['checkout'])\r\n        this.currentTab = \"ADDRESS\";\r\n    })\r\n    this._eventService.showDummyCartItems.subscribe((response: boolean) => {\r\n      this.responseData = this.styles?.cartItemsStyling && this.edit ? this.dummyCartItems : this.edit ? undefined : this.responseData;\r\n    })\r\n    this.getTrialCart();\r\n    this.getIndexDBData();\r\n    this.getSchemeDetails();\r\n    this.getEcommerceConfigs();\r\n    this.styles = this.data?.styles;\r\n    // console.log(this.data)\r\n  }\r\n  dummyCartItems: any = {\r\n    \"cartId\": \"1f0dd796-b9d8-6c1f-8d3b-d7330cc27a9f\",\r\n    \"businessId\": \"1f0dca42-fe4e-606c-ae3b-e94230be5cd2\",\r\n    \"pgOrderId\": null,\r\n    \"orderedItems\": [\r\n      {\r\n        \"itemId\": \"1efb5ff2-3df3-6dca-ae25-b910d9b2006f\",\r\n        \"varientId\": \"1efb5ff2-3df3-6dca-ae25-b910d9b2006f\",\r\n        \"businessId\": \"1efb3bdc-fd68-65d0-9039-6dac09c61303\",\r\n        \"itemName\": \"XXXXXXXXXXXX\",\r\n        \"businessName\": null,\r\n        \"imgUrl\": \"https://i.postimg.cc/hPS2JpV0/no-image-available.jpg\",\r\n        \"itemVariant\": null,\r\n        \"taxCategory\": null,\r\n        \"quantity\": 1,\r\n        \"price\": 22000.0,\r\n        \"itemTax\": 0.0,\r\n        \"discountedPrice\": 22000.0,\r\n        \"discountAmount\": 0.0,\r\n        \"taxAfterDiscount\": 0.0,\r\n        \"sellingPrice\": 22000.0,\r\n        \"value\": 0.0,\r\n        \"rating\": 0,\r\n        \"review\": null,\r\n        \"reviewImages\": null\r\n      },\r\n    ],\r\n    \"billdetails\": {\r\n      \"totalNetValue\": 27000.0,\r\n      \"totalGrossValue\": 27250.0,\r\n      \"totalTax\": 250.0,\r\n      \"finalPrice\": 27250.0,\r\n      \"taxBreakup\": {\r\n        \"cgstValue\": 125.0,\r\n        \"sgstValue\": 125.0,\r\n        \"igstValue\": 0.0\r\n      },\r\n      \"deliveryCharges\": 0.0,\r\n      \"couponId\": null,\r\n      \"couponCode\": null,\r\n      \"discountAmount\": 0.0,\r\n      \"totalTaxAfterDiscount\": 0.0,\r\n      \"orraSchemeCode\": null,\r\n      \"orraSchemeRedeemedAmount\": 0.0\r\n    },\r\n    \"platform\": \"WEB\",\r\n    \"addressDetails\": null,\r\n    \"userDetails\": {\r\n      \"userId\": \"87896c32-41af-497d-a8df-134b368ee1b2\",\r\n      \"userName\": \"jothisha\",\r\n      \"mobile\": \"9381471527\",\r\n      \"email\": \"jothisha@tejsoft.com\"\r\n    },\r\n    \"createdTimeStamp\": \"2025-12-20T07:57:43.180+00:00\",\r\n    \"totalAmount\": 27250.0,\r\n    \"cartType\": \"CART\"\r\n  }\r\n  getEcommerceConfigs() {\r\n    this.restService.getEcommerceConfigs().subscribe((res: any) => {\r\n      this.ecomConfigs = res?.data\r\n    })\r\n  }\r\n\r\n  schemeList: any[] = []\r\n  getSchemeDetails() {\r\n    this.restService.getAllOrraScheme().subscribe((res: any) => {\r\n      this.schemeList = [res.data];\r\n    })\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.loadingSubscription?.unsubscribe();\r\n  }\r\n  onToggleChange() {\r\n\r\n    if (!this.userDetails) {\r\n      this.selectMatureScheme = false;\r\n      this.messageService.add({ severity: 'error', summary: 'Scheme', detail: 'Login First to redeem' });\r\n      this.router.navigate(['/login'])\r\n      return;\r\n    }\r\n    this.selectMatureScheme = !this.selectMatureScheme;\r\n    if (!this.selectMatureScheme)\r\n      this.showReedemError = false\r\n    if (!this.selectMatureScheme && this.cartInfo.billdetails.orraSchemeCode) {\r\n      let request: any = { \"amount\": this.cartInfo.billdetails.orraSchemeRedeemedAmount, \"GPPId\": this.cartInfo.billdetails.orraSchemeCode }\r\n      this.redeemScheme(request, true)\r\n    }\r\n  }\r\n  getTrialCart() {\r\n    let user: User | null = this.storageService.getUser()\r\n    if (user) {\r\n      this.restService.getUserItems(user.userId, 'TRIAL_CART').subscribe((res: any) => {\r\n        this.trialCartItem = res?.data?.[0]?.orderedItems ?? []\r\n      })\r\n    } else {\r\n      this.getTrialCartIndexDBData();\r\n    }\r\n  }\r\n\r\n  getTrialCartIndexDBData() {\r\n    this.storageService.getTrialCart().then((response) => {\r\n      response.onsuccess = (userTrialCartResponse: any) => {\r\n        this.trialCartItem = userTrialCartResponse.target.result;\r\n      }\r\n    })\r\n  }\r\n\r\n  updateUserCart() {\r\n    const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n\r\n    this.userDetails = this.storageService.getUser() as User;\r\n    this.cartInfo.userDetails = {\r\n      \"userId\": this.userDetails?.userId,\r\n      \"userName\": this.userDetails?.contact.name,\r\n      \"mobile\": this.userDetails?.contact.mobile,\r\n      \"email\": this.userDetails?.contact.email,\r\n    }\r\n    this.restService.getUserItems(this.userDetails.userId, \"CART\").subscribe((response: any) => {\r\n      const tempUserCart = response?.data?.[0]?.orderedItems ?? [];\r\n      localStorage.setItem('cartId', response.data?.[0]?.cartId);\r\n      this.cartInfo[\"cartId\"] = response.data?.[0]?.cartId;\r\n      this.cartInfo.billdetails['orraSchemeRedeemedAmount'] = response?.data?.[0]?.billdetails?.orraSchemeRedeemedAmount\r\n      this.cartInfo.billdetails['orraSchemeCode'] = response?.data?.[0]?.billdetails?.orraSchemeCode\r\n      this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.[0]?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n      if (response.data?.[0]?.billdetails?.orraSchemeCode)\r\n        this.selectMatureScheme = true\r\n      this.getCouponList();\r\n      if (response.data?.[0]?.orderedItems?.length > 0) {\r\n        this.mergeOrderItems(tempUserCart);\r\n        this.storageService.addAllProductsToCart(this.cartInfo.orderedItems).oncomplete = () => {\r\n\r\n          this.storageService.getUserCart().then((cartResponse) => {\r\n            cartResponse.onsuccess = (cartData: any) => {\r\n              if (!(localStorage.getItem(\"couponId\") == \"undefined\" || localStorage.getItem(\"couponId\") == \"null\"))\r\n                this.cartInfo.billdetails.couponId = localStorage.getItem(\"couponId\");\r\n              if (!(localStorage.getItem(\"couponCode\") == \"undefined\" || localStorage.getItem(\"couponCode\") == \"null\"))\r\n                this.cartInfo.billdetails.couponCode = localStorage.getItem(\"couponCode\");\r\n              const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n              restResponse.then((response: any) => {\r\n                this.cartInfo.billdetails.totalGrossValue = 0;\r\n                this.cartInfo.billdetails.totalTax = 0;\r\n                this.cartInfo.billdetails.deliveryCharges = 0;\r\n                this.cartInfo.billdetails.totalNetValue = 0;\r\n                this.cartInfo.totalAmount = 0;\r\n\r\n                this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n                this.USER_CART_ITEMS.forEach((item) => {\r\n                  this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n                  this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n                })\r\n                this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n                this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n                this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n                this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n                this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n                this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n                // this.storageService.addAllProductsToCart(this.cartInfo.orderedItems)\r\n                this.responseData = this.cartInfo;\r\n              })\r\n            }\r\n            cartResponse.onerror = (cartData: any) => {\r\n              this.messageService.add({ severity: 'error', summary: 'Error', detail: 'Failed to update cart details' });\r\n            }\r\n          })\r\n        }\r\n      } else {\r\n        this.storageService.getUserCart().then((cartResponse) => {\r\n          cartResponse.onsuccess = (cartData: any) => {\r\n\r\n            this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n            this.cartInfo.billdetails.totalGrossValue = 0;\r\n            this.cartInfo.billdetails.totalTax = 0;\r\n            this.cartInfo.billdetails.totalTaxAfterDiscount = cartData.billdetails?.totalTaxAfterDiscount ?? 0;\r\n            this.cartInfo.billdetails.deliveryCharges = 0;\r\n            this.cartInfo.billdetails.totalNetValue = 0;\r\n            this.cartInfo.totalAmount = 0;\r\n\r\n            this.USER_CART_ITEMS.forEach((item) => {\r\n              this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n              this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n            })\r\n            this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n            this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n            this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n            this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n            this.responseData = this.cartInfo;\r\n            this.restService.addItemToDB(this.responseData).subscribe((response: any) => {\r\n              localStorage.setItem('cartId', response.data?.cartId);\r\n              this.cartInfo[\"cartId\"] = response.data?.cartId;\r\n              this.responseData[\"cartId\"] = this.cartInfo[\"cartId\"];\r\n            })\r\n          }\r\n        })\r\n      }\r\n    })\r\n  }\r\n\r\n  getDefaultAddress() {\r\n    if ((this.userDetails?.addressDetailsList?.length || 0) == 0)\r\n      return;\r\n\r\n    this.selectedAddressIdx = this.userDetails?.addressDetailsList?.findIndex(address => address.default === true) ?? -1;\r\n    this.defaultAddress = this.selectedAddressIdx !== -1\r\n      ? this.userDetails?.addressDetailsList[this.selectedAddressIdx]\r\n      : this.userDetails?.addressDetailsList?.[0];\r\n  }\r\n  get stylesLayout() {\r\n    return { ...this.styles?.layout } as LayOutModel;\r\n  }\r\n\r\n  mergeOrderItems(syncedItems: any[]) {\r\n    for (let product of syncedItems) {\r\n      let itemFound = false;\r\n      for (let cartItem of this.cartInfo.orderedItems) {\r\n        if (cartItem.varientId === product.varientId) {\r\n          itemFound = true;\r\n          // cartItem.quantity = product.quantity;\r\n        }\r\n      }\r\n      if (!itemFound) {\r\n        this.cartInfo.orderedItems.push(product);\r\n      }\r\n    }\r\n  }\r\n\r\n  getCouponList() {\r\n    if (!this.cartInfo.cartId && !(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo.cartId = localStorage.getItem(\"cartId\");\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n\r\n    })\r\n  }\r\n  removeCoupon(event: MouseEvent) {\r\n    this.cartInfo.billdetails.couponId = \"\";\r\n    this.cartInfo.billdetails.couponCode = \"\";\r\n    const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    restResponse.then((response: any) => {\r\n\r\n      this.calculateCart(response);\r\n      localStorage.removeItem(\"couponId\");\r\n      localStorage.removeItem(\"couponCode\");\r\n      this.messageService.add({ severity: 'error', summary: 'Coupon', detail: 'Coupon Removed' });\r\n      this.cartInfo.billdetails.discountAmount = 0;\r\n      this.couponDialogRef?.close();\r\n    })\r\n    event.preventDefault();\r\n  }\r\n\r\n  getIndexDBData() {\r\n    this.storageService.getUserCart().then((cartResponse) => {\r\n      const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n      this.cartInfo.billdetails.totalGrossValue = 0;\r\n      this.cartInfo.billdetails.totalTax = 0;\r\n      this.cartInfo.billdetails.totalNetValue = 0;\r\n      this.cartInfo.totalAmount = 0;\r\n      this.cartInfo.billdetails.deliveryCharges = 0;\r\n\r\n      cartResponse.onsuccess = (cartData: any) => {\r\n        this.USER_CART_ITEMS = cartData.target.result as unknown as OrderedItems[];\r\n        this.USER_CART_ITEMS.forEach((item) => {\r\n          this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n          this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n        })\r\n\r\n        this.cartInfo.billdetails.totalTaxAfterDiscount = cartData.billdetails?.totalTaxAfterDiscount ?? 0;\r\n        this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n        this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n        this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n        this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n        if (this.storageService.getUser())\r\n          this.updateUserCart();\r\n\r\n        this.responseData = this.cartInfo;\r\n      }\r\n    })\r\n  }\r\n  proceedToCheckout() {\r\n    if (this.storageService.getUser()) {\r\n      this.currentTab = \"ADDRESS\";\r\n      this.getDefaultAddress()\r\n      if (this.isMobile) {\r\n        document.body.scrollTop = 0;\r\n        document.documentElement.scrollTop = 0;\r\n      }\r\n\r\n    } else {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to order' });\r\n      this.router.navigate(['/login'], { queryParams: { cart: true } });\r\n    }\r\n  }\r\n\r\n  private toSlug(input: string | null | undefined): string | null {\r\n    if (!input)\r\n      return null;\r\n\r\n    const noWhitespace = input.replace(/\\s+/g, '-');\r\n    const normalized = noWhitespace.normalize('NFD');\r\n    const slug = normalized.replace(/[^\\w-]/g, '');\r\n\r\n    return slug\r\n      .toLowerCase()\r\n      .replace(/-+/g, '-')\r\n      .replace(/^-|-$/g, '');\r\n  }\r\n\r\n  goToProductDetails(product: OrderedItems) {\r\n    const slug = product.slugifiedName || this.toSlug(product.itemName);\r\n    if (!slug)\r\n      return;\r\n\r\n    this.router.navigate(['/details', slug]);\r\n  }\r\n  proceedToListPage() {\r\n    this.router.navigate(['/']);\r\n  }\r\n  removeItem(item: OrderedItems) {\r\n\r\n    Swal.fire({\r\n      icon: \"warning\",\r\n      html: \"<span>You can move </span> <b>\" + item.itemName + \"</b> <span>to wishlist so you can buy later.</span>\",\r\n      confirmButtonText: \"Move to wishlist\",\r\n      showDenyButton: true,\r\n      showCloseButton: true,\r\n      denyButtonText: \"Delete item\",\r\n      denyButtonColor: \"#d5d5d5ff\",\r\n      allowOutsideClick: false,\r\n    }).then((response) => {\r\n      if (response.isConfirmed) {\r\n        if (this.cartType === 'SHOPPING') {\r\n          this.removeItemFromCart(item);\r\n        } else {\r\n          this.removeTrialItem(item)\r\n        }\r\n        this.moveItemToWishlist(item);\r\n      } else if (response.isDenied) {\r\n        if (this.cartType === 'SHOPPING') {\r\n          this.removeItemFromCart(item);\r\n        } else {\r\n          this.removeTrialItem(item)\r\n        }\r\n      }\r\n    })\r\n  }\r\n  private moveItemToWishlist(item: OrderedItems) {\r\n    this.cartService.addItemToFavFromCart(item);\r\n  }\r\n  private removeItemFromCart(item: OrderedItems) {\r\n    item.quantity = 0;\r\n    if (this.USER_CART_ITEMS)\r\n      this.USER_CART_ITEMS = this.USER_CART_ITEMS.filter((product: any) => product.varientId != item.varientId);\r\n    this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    this.responseData = this.cartInfo;\r\n    this.cartService.addItemFromCartPage(item, this.responseData).subscribe((response: any) => {\r\n      const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n      this.cartInfo.billdetails.totalGrossValue = 0;\r\n      this.cartInfo.billdetails.totalTax = 0;\r\n      this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n      this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n      this.cartInfo.billdetails.totalNetValue = 0;\r\n      this.cartInfo.totalAmount = 0;\r\n      this.cartInfo.billdetails.deliveryCharges = 0;\r\n      this.cartInfo.couponCode = response.data?.billdetails?.couponCode;\r\n      this.cartInfo.couponId = response.data?.billdetails?.couponId;\r\n\r\n      response?.data?.orderedItems.forEach((item: any) => {\r\n        this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n        this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n      })\r\n      this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n      this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n      this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n      this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    })\r\n  }\r\n  addToCart(item: OrderedItems, quantity: number) {\r\n    // if (type == 'ADD') {\r\n    //   item.quantity += 1;\r\n    // }\r\n    // else {\r\n    //   item.quantity -= 1;\r\n    // }\r\n    this.showReedemError = false\r\n    // item.quantity = quantity\r\n    if (item.quantity && item.quantity > 0) {\r\n      this.cartService.addItemFromCartPage(item, this.responseData).subscribe((response: any) => {\r\n        const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n        this.cartInfo.billdetails.totalGrossValue = 0;\r\n        this.cartInfo.billdetails.totalTax = 0;\r\n        this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n        this.cartInfo.billdetails.totalNetValue = 0;\r\n        this.cartInfo.totalAmount = 0;\r\n        this.cartInfo.billdetails.deliveryCharges = 0;\r\n        this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n\r\n        response?.data?.orderedItems.forEach((item: any) => {\r\n          this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n          this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n        })\r\n        this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n        this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n        this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n        this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n      })\r\n    } else {\r\n      this.removeItem(item);\r\n    }\r\n  }\r\n  cartId: any\r\n  placeOrderLoader: boolean = false;\r\n  async proceedToPayment() {\r\n    this.placeOrderLoader = true;\r\n    let result: any = \"\";\r\n\r\n    try {\r\n      const rawData = this.storageService.getReferralDetails();\r\n      const referralDetails = rawData ? JSON.parse(rawData) : {};\r\n\r\n      if (referralDetails && Object.keys(referralDetails).length > 0) {\r\n        result =\r\n          Object.values(referralDetails).find((item: any) =>\r\n            Array.isArray(item?.referralEvents) &&\r\n            item.referralEvents.includes('PRODUCT_PURCHASE')\r\n          ) || \"\";\r\n      }\r\n\r\n    } catch (error) {\r\n      console.error(\"Invalid referralDetails JSON\", error);\r\n    }\r\n\r\n    if (!this.storageService.getUser()) {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to order' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n\r\n    const isPaymentGatewayEnabled = localStorage.getItem(\"isPaymentGatewayEnabled\") ? localStorage.getItem(\"isPaymentGatewayEnabled\") == \"true\" : true;\r\n    const merchantId = localStorage.getItem('pMId') == \"null\" || localStorage.getItem('pMId') == \"undefined\" ? null : localStorage.getItem('pMId');\r\n\r\n    if (isPaymentGatewayEnabled && !merchantId) {\r\n      this.messageService.add({ severity: 'error', summary: 'Merchant onboarded', detail: 'Merchant is not onboarded' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n\r\n    const userDetail = this.storageService.getUser() as User;\r\n    const address = userDetail?.addressDetailsList[this.selectedAddressIdx] as Address;\r\n    if (address?.receiverName?.length == 0) {\r\n      this.messageService.add({ severity: 'error', summary: 'Payment Failure', detail: 'Please provide address details' });\r\n      this.placeOrderLoader = false;\r\n      return;\r\n    }\r\n    if (!(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo[\"cartId\"] = localStorage.getItem(\"cartId\");\r\n    else {\r\n      this.messageService.add({ severity: 'info', summary: 'Please wait', detail: 'We are processing your payment', life: 2000 });\r\n      await this.restService.addItemToDB(this.cartInfo).toPromise().then((response: any) => {\r\n        localStorage.setItem(\"cartId\", response.data?.cartId);\r\n        this.cartId = response.data?.cartId;\r\n        this.cartInfo[\"cartId\"] = response.data?.cartId;\r\n      })\r\n    }\r\n    if (this?.isPointsRedeeming === true) {\r\n      if ((this?.redemptionPoints?.pointsConvertedRupees === this.responseData?.totalAmount) || (this?.redemptionPoints?.pointsConvertedRupees > this.responseData?.totalAmount)) {\r\n        this.paymentWithCompletePoints()\r\n        return;\r\n      }\r\n    }\r\n    this.cartInfo[\"addressDetails\"] = address;\r\n    const updateAddress = await this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    const payload = {\r\n      \"userId\": userDetail?.userId,\r\n      \"cartId\": localStorage.getItem('cartId'),\r\n      // \"orderAmount\": this.isPointsRedeeming\r\n      //   ? Number(((this.responseData?.totalAmount ?? 0) - (this?.totalSavingAmt || 0)).toFixed(2))\r\n      //   : this.selectedVoucherAmount ? Number(((this.responseData?.totalAmount ?? 0) - (this?.selectedVoucherAmount || 0)).toFixed(2)) : Number((this.responseData?.totalAmount ?? 0).toFixed(2)),\r\n      \"orderAmount\": this.isPointsRedeeming\r\n        ? Number(((this.responseData?.totalAmount ?? 0) - (this?.totalSavingAmt || 0)).toFixed(2))\r\n        : this.couponValueType === 'AMOUNT'\r\n          ? Number(((this.responseData?.totalAmount ?? 0) - (this?.selectedVoucherAmount || 0)).toFixed(2))\r\n          : this.couponValueType === 'PERCENTAGE'\r\n            ? Number(((this.responseData?.totalAmount ?? 0) - (this?.percentageReduced || 0)).toFixed(2))\r\n            : Number((this.responseData?.totalAmount ?? 0).toFixed(2)),\r\n      \"isPaymentGatewayEnabled\": isPaymentGatewayEnabled,\r\n      \"contactDetails\": {\r\n        \"name\": address?.receiverName,\r\n        \"mobile\": address?.receiverPhone,\r\n        \"countryCode\": \"91\",\r\n        \"email\": address?.receiverEmail\r\n      },\r\n      \"paymentMerchantId\": merchantId,\r\n      \"isJewellery\": this?.isJewellery,\r\n      \"referralId\": result?.referralUniqueId,\r\n      \"rewardUsed\": this?.isPointsRedeeming ? \"REWARD_POINTS\" : this?.appliedVoucher ? \"VOUCHER\" : null,\r\n      \"pointsUsed\": this?.isPointsRedeeming ? this.usedPoints : 0,\r\n      \"pointsConvertedINR\": this?.isPointsRedeeming ? this.totalSavingAmt : 0,\r\n      \"voucherValue\": this.selectedVoucherAmount ? this.selectedVoucherAmount : this.percentageReduced ? this.percentageReduced : 0,\r\n      \"voucherId\": this?.appliedVoucher ? this.selectedVoucherId : null,\r\n      \"voucherCode\": this?.appliedVoucher ? this.selectedVoucherCode : ''\r\n    }\r\n    // console.log(payload)\r\n    // return\r\n    this.restService.createPaymentToken(payload).subscribe((paymentDetails: any) => {\r\n      if (isPaymentGatewayEnabled) {\r\n        this._eventService.cashFreeEvent.emit(paymentDetails);\r\n        this.placeOrderLoader = false;\r\n      }\r\n      else {\r\n\r\n        localStorage.removeItem(\"orderId\");\r\n        localStorage.removeItem(\"cartId\");\r\n        localStorage.removeItem(\"paymentFor\");\r\n        this.storageService.clearUserCart();\r\n        Swal.fire({\r\n          icon: \"success\",\r\n          title: \"Hurray\",\r\n          text: \"Order placed successfully\",\r\n          confirmButtonText: \"See Details\"\r\n        }).then((response) => {\r\n          if (response.isConfirmed) {\r\n            this.router.navigate(['/profile']);\r\n          }\r\n        })\r\n        this.placeOrderLoader = false;\r\n      }\r\n    }, (error) => {\r\n      if (error?.error?.code == 409) {\r\n        Swal.fire({\r\n          icon: \"info\",\r\n          html: \"<p>\" + error?.error?.message.replace(/ *\\([^)]*\\) */g, \"\") + \"</p>\",\r\n          showCloseButton: true\r\n        }).then(async (response) => {\r\n          this.currentTab = \"BAG\";\r\n          this.messageService.add({ severity: 'info', summary: 'Processing', detail: 'Please wait, updaing your cart', life: 2000 });\r\n          const regExp = /{([^}]+)}/g;\r\n          const id = regExp.exec(error.message)?.[1];\r\n          let itemDetail: Product | null = null;\r\n          const productDetailsAsync = await this.restService.getProductDetails(id).toPromise().then((response) => {\r\n            itemDetail = response[0] as Product;\r\n          })\r\n          if (response.isDismissed) {\r\n            this.cartInfo.orderedItems.forEach((item: OrderedItems) => {\r\n              if (item.itemId == itemDetail?.itemId)\r\n                item.quantity = itemDetail?.itemInventory.openingStock;\r\n            })\r\n            const addItemDBAsync = await this.restService.addItemToDB(this.cartInfo).toPromise();\r\n            const addItemIndexDBAsync = await this.storageService.addAllProductsToCart(this.cartInfo.orderedItems);\r\n          } else if (response.isConfirmed) {\r\n            this.cartInfo.orderedItems = this.cartInfo.orderedItems.filter((item: OrderedItems) => item.itemId != itemDetail?.itemId);\r\n            const addItemDBAsync = await this.restService.addItemToDB(this.cartInfo).toPromise();\r\n            const addItemIndexDBAsync = await this.storageService.addAllProductsToCart(this.cartInfo.orderedItems);\r\n            this.proceedToPayment();\r\n          }\r\n        })\r\n      } else {\r\n        this.messageService.add({ severity: 'error', summary: 'Payment Failure', detail: 'Please try again' });\r\n      }\r\n      this.placeOrderLoader = false;\r\n    })\r\n  }\r\n\r\n\r\n  addressSelected(index: number) {\r\n    this.selectedAddressIdx = index;\r\n  }\r\n\r\n  isItemOutOfStock(product: OrderedItems) {\r\n    return false; // need condition\r\n  }\r\n  getKeys(object: Object): string[] {\r\n    if (object)\r\n      return Object.keys(object);\r\n    return [];\r\n  }\r\n\r\n  editSection() {\r\n\r\n    if (window.innerWidth <= 475)\r\n      return;\r\n\r\n    this._eventService.toggleEditorEvent.emit(false);\r\n    setTimeout(() => {\r\n      this._eventService.editSection.emit({ data: this.data });\r\n    }, 100);\r\n  }\r\n  closeWindow() {\r\n    this.dialogRef.close();\r\n  }\r\n  couponDialogRef: MatDialogRef<unknown> | null = null;\r\n  openDialog(container: any) {\r\n\r\n    if (this.cartInfo?.billdetails?.couponId)\r\n      return;\r\n\r\n    if (!this.cartInfo.cartId && !(localStorage.getItem(\"cartId\") == \"undefined\" || localStorage.getItem(\"cartId\") == \"null\"))\r\n      this.cartInfo.cartId = localStorage.getItem(\"cartId\");\r\n\r\n    // if (!this.cartInfo?.cartId) {\r\n    //   this.messageService.add({ severity: 'error', summary: 'You are not logged in', detail: 'Please login first to apply coupon' });\r\n    //   return;\r\n    // }\r\n\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n      console.log(this.couponList);\r\n      // if (!!this.userDetails)\r\n      this.couponDialogRef = this.matDialog.open(container, { panelClass: 'sidepanel-class' });\r\n      // else {\r\n      // this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to apply coupon' });\r\n      // }\r\n    })\r\n  }\r\n\r\n  listRedemptionCoupons: any;\r\n  appliedVoucher: any;\r\n  redemptionType: \"COUPONS\" | \"VOUCHERS\" = \"COUPONS\"\r\n  redemptionCouponType: \"REWARDS\" | \"DISCOUNTS\" = \"REWARDS\"\r\n  selectedVoucherId: any\r\n  selectedVoucherAmount: any\r\n  selectedVoucherCode: any\r\n  listRedemptionVouchers: any\r\n  selectedVoucherPercentage: any\r\n  percentageReduced: any\r\n  couponValueType: string = ''\r\n  addRedemptionCoupon(container: any) {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    const userDetails = (this.storageService.getUser() as User);\r\n    let userId = userDetails?.userId\r\n    let orderValue = this.responseData?.billdetails?.totalNetValue\r\n    // let businessId = '1f12df16-8154-6cea-85c5-fb616c47aaf4';\r\n    // let userId = '29d2b424-680c-46bd-b18f-b86b346eb1cf'; \r\n    // let orderValue = this.responseData?.billdetails?.totalNetValue;\r\n\r\n    this.restService.getRedeemPoints(businessId, userId, 'PRODUCT_PURCHASE', orderValue, false).subscribe({\r\n      next: (res: any) => {\r\n        console.log(res)\r\n        this.listRedemptionCoupons = res;\r\n      },\r\n      error: (err: any) => {\r\n        this.messageService.add({ severity: 'error', summary: 'Coupons Failed', detail: 'Failed to load Coupons' });\r\n      }\r\n    });\r\n    this.restService.applicableDiscountList(this.cartInfo.cartId).subscribe((response: any) => {\r\n      this.couponList = response.data?.filter((coupon: any) => coupon.active)?.map((coupon: any) => {\r\n        return {\r\n          discountType: coupon.discount,\r\n          discountName: coupon.couponTitle,\r\n          discountDescription: coupon.couponDescription,\r\n          couponCode: coupon.couponCode,\r\n          couponId: coupon.couponId,\r\n          applicable: coupon.applicable,\r\n          status: coupon.active,\r\n          validTo: coupon.expires,\r\n          validFrom: coupon.validFrom\r\n        }\r\n      });\r\n    })\r\n    this.couponDialogRef = this.matDialog.open(container, { panelClass: 'sidepanel-class' });\r\n  }\r\n\r\n  applyRedemptionCoupon(voucher: any) {\r\n    if (this.isPointsRedeeming) {\r\n      this.messageService.add({ severity: 'info', summary: 'Coupon not applicable', detail: 'You can not add a coupon when points are being redeemed' });\r\n      return;\r\n    }\r\n    if (this.appliedVoucher) {\r\n      this.removeRedemptionCoupon();\r\n    }\r\n    this.appliedVoucher = voucher;\r\n    this.selectedVoucherId = voucher.couponId;\r\n    this.selectedVoucherCode = voucher.voucherCode;\r\n    this.selectedVoucherPercentage = voucher.couponValue\r\n\r\n    let total = Number(this.responseData?.totalAmount) || 0;\r\n    let percentage = Number(this.selectedVoucherPercentage) || 0;\r\n    let amt = total * (percentage / 100);\r\n\r\n    if (voucher.couponValueType === 'PERCENTAGE') {\r\n      this.couponValueType = \"PERCENTAGE\"\r\n      if (amt > voucher.maxRedeemableAmount) {\r\n        this.percentageReduced = voucher.maxRedeemableAmount\r\n      }\r\n      else {\r\n        this.percentageReduced = amt\r\n      }\r\n    }\r\n    else {\r\n      this.couponValueType = \"AMOUNT\"\r\n      this.selectedVoucherAmount = voucher.couponValue;\r\n    }\r\n\r\n    this.closeDialogRef();\r\n    Swal.fire({\r\n      icon: \"success\",\r\n      title: `You saved ${this.selectedVoucherAmount ? '₹' : ''} ${this.selectedVoucherAmount ? this.selectedVoucherAmount : this.selectedVoucherPercentage} ${this.selectedVoucherAmount ? '' : '%'} on this payment`,\r\n      text: `Coupon code ${this.selectedVoucherCode} has been applied successfully`,\r\n      confirmButtonText: \"YAY!\",\r\n      confirmButtonColor: \"#111\",\r\n    }).then((res) => {\r\n      if (res.isConfirmed || res.isDismissed) {\r\n        // popup closed\r\n      }\r\n    })\r\n  }\r\n\r\n  removeRedemptionCoupon(event?: Event) {\r\n    event?.stopPropagation();\r\n    this.appliedVoucher = null;\r\n    this.selectedVoucherId = null;\r\n    this.selectedVoucherCode = null;\r\n    this.selectedVoucherAmount = null;\r\n  }\r\n\r\n  searchIfApplicable() { }\r\n  closeDialogRef() {\r\n    this.couponDialogRef?.close();\r\n  }\r\n  applyCoupon(coupon: Coupon) {\r\n\r\n    if (!coupon.applicable)\r\n      return;\r\n\r\n    this.cartInfo.billdetails.couponCode = coupon.couponCode;\r\n    this.cartInfo.billdetails.couponId = coupon.couponId;\r\n    const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();\r\n    restResponse.then((response: any) => {\r\n\r\n      localStorage.setItem(\"couponId\", coupon.couponId);\r\n      localStorage.setItem(\"couponCode\", coupon.couponCode);\r\n      this.calculateCart(response);\r\n\r\n      this.messageService.add({ severity: 'success', summary: 'Coupon', detail: 'Coupon Applied' });\r\n      this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n      this.couponDialogRef?.close();\r\n    })\r\n  }\r\n  calculateCart(response: any) {\r\n    const deliveryOption = JSON.parse(localStorage.getItem(\"deliveryOptions\") ?? \"{}\");\r\n    this.cartInfo.billdetails.totalGrossValue = 0;\r\n    this.cartInfo.billdetails.totalTax = 0;\r\n    this.cartInfo.billdetails.totalTaxAfterDiscount = response?.data?.billdetails?.totalTaxAfterDiscount ?? 0;\r\n    this.cartInfo.billdetails.deliveryCharges = 0;\r\n    this.cartInfo.billdetails.totalNetValue = 0;\r\n    this.cartInfo.billdetails.discountAmount = response?.data?.billdetails?.discountAmount ?? 0;\r\n    this.cartInfo.totalAmount = 0;\r\n\r\n    if (this.USER_CART_ITEMS) {\r\n\r\n      this.USER_CART_ITEMS.forEach((item) => {\r\n        this.cartInfo.billdetails.totalNetValue += (item.discountedPrice * (item.quantity ?? 1));\r\n        this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));\r\n      })\r\n      this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);\r\n      this.cartInfo.billdetails.totalGrossValue = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();\r\n      this.cartInfo.totalAmount = this.cartInfo.billdetails.totalGrossValue + this.cartInfo.billdetails.deliveryCharges - this.cartInfo.billdetails.discountAmount;\r\n      this.cartInfo.orderedItems = this.USER_CART_ITEMS;\r\n    }\r\n    this.responseData = this.cartInfo;\r\n  }\r\n\r\n  getTaxAmount(): number {\r\n    return !this.cartInfo.billdetails?.couponId ? (this.cartInfo.billdetails.totalTax ?? 0) : (this.cartInfo.billdetails?.totalTaxAfterDiscount ?? 0);\r\n  }\r\n\r\n  get getAddressList() {\r\n    return this.userDetails ? [...this.userDetails?.addressDetailsList] : [];\r\n  }\r\n  get isMobile() {\r\n    return window.innerWidth <= 475;\r\n  }\r\n  get currency(): string {\r\n    return BUSINESS_CONSTANTS.CURRENCY;\r\n  }\r\n\r\n  changeAddress() {\r\n    this.matDialog.open(AddressListComponent, { panelClass: 'sidepanel-class', data: { addressList: this.getAddressList } }).afterClosed().subscribe((res: any) => {\r\n      this.userDetails = this.storageService.getUser() as User;\r\n      this.getDefaultAddress();\r\n    })\r\n  }\r\n\r\n  addAddress() {\r\n    this.matDialog.open(AddressComponent, { panelClass: ['sidepanel-class', 'address-class'], data: { addressList: this.getAddressList, 'editIndex': -1 } }).afterClosed().subscribe((res: any) => {\r\n      this.userDetails = this.storageService.getUser() as User;\r\n      this.getDefaultAddress();\r\n    })\r\n  }\r\n\r\n  scroll(e: WheelEvent) {\r\n    const d = this.d2.nativeElement;\r\n    const atTop = d.scrollTop === 0;\r\n    const atBottom = d.scrollTop >= d.scrollHeight - d.clientHeight;\r\n    if ((atTop && e.deltaY < 0) || (atBottom && e.deltaY > 0)) {\r\n      return;\r\n    }\r\n    e.preventDefault();\r\n    d.scrollTop = Math.max(0, Math.min(d.scrollTop + e.deltaY * 2, d.scrollHeight - d.clientHeight));\r\n  }\r\n  selectedRedmpationData: any;\r\n  selectScheme() {\r\n    let dialog = this.matDialog.open(SchemeSelectionComponent, {});\r\n    dialog.afterClosed().subscribe((response: any) => {\r\n      this.selectedRedemption = true;\r\n      this.selectedRedmpationData = response;\r\n    });\r\n  }\r\n  scheduleVideoCall(items: any) {\r\n    this.matDialog.open(ScheduleVideoCallComponent, { panelClass: 'sidepanel-class', data: { data: this.data, orderItems: items } });\r\n  }\r\n  getButtonId(index: number) {\r\n    return this.data?.action?.buttons[index]?.id ?? \"\";\r\n  }\r\n  getButtonStyle(index: number) {\r\n    return this.data?.action?.buttons[index]?.styles;\r\n  }\r\n\r\n  changeQuantity(quantity: any, item: OrderedItems) {\r\n    this.addToCart(item, quantity.target.value);\r\n  }\r\n\r\n  removeTrialItem(item: OrderedItems) {\r\n    this.trialCartItem = this.trialCartItem?.filter((product: OrderedItems) => item.varientId != product.varientId) ?? [];\r\n\r\n    const user = this.storageService.getUser()\r\n    if (user) {\r\n      let request: syncItemToServerDBRequest = new syncItemToServerDBRequest(user.userId, 'TRIAL_CART', [item])\r\n      this.restService.deleteItemFromCart(request).subscribe((res: any) => {\r\n        this.messageService.add({ severity: 'success', summary: 'Trial Product', detail: 'Deleted successfully' });\r\n      })\r\n    } else {\r\n      this.storageService.removeProductFromTrialCart(item.varientId)\r\n      this.messageService.add({ severity: 'success', summary: 'Trial Product', detail: 'Deleted successfully' });\r\n    }\r\n  }\r\n\r\n  bookAppointment() {\r\n    const user: User | null = this.storageService.getUser();\r\n    if (!user) {\r\n      this.messageService.add({ severity: 'info', summary: 'Login', detail: 'Please login with mobile number to Book' });\r\n      this.router.navigate(['/login'], { queryParams: { tryAtHome: true } });\r\n      return;\r\n    }\r\n\r\n    this.router.navigate(['/home-appointment'])\r\n  }\r\n  showReedemError: boolean = false;\r\n  vaildAmount: number = 0\r\n  redeemScheme(scheme: any, action: boolean) {\r\n    if (((this.responseData?.totalAmount ?? 0) - (this.responseData?.billdetails?.discountAmount ?? 0)) < scheme.amount) {\r\n      this.messageService.add({ severity: 'error', summary: 'Scheme Redeem', detail: 'Cart amount should be more that redeem amount' });\r\n      return;\r\n    }\r\n\r\n    this.restService.redeemScheme(scheme, this.cartInfo.cartId, action).subscribe((res: any) => {\r\n      this.cartInfo.billdetails.orraSchemeRedeemedAmount = scheme.amount\r\n      this.cartInfo.billdetails.orraSchemeCode = scheme.GPPId\r\n    })\r\n  }\r\n\r\n  getUrl() {\r\n    return window?.location?.origin?.includes('caratlane') || window?.location?.origin?.includes('orra')\r\n  }\r\n  get fontColor(): string {\r\n    let color = this.styles?.background?.accentColor;\r\n    if (!color) return '#000';\r\n\r\n    // if gradient, extract first hex color\r\n    const gradientMatch = color.match(/#([0-9a-fA-F]{6})/);\r\n    if (gradientMatch) {\r\n      color = gradientMatch[0];\r\n    }\r\n\r\n    color = color.replace('#', '');\r\n\r\n    const r = parseInt(color.substring(0, 2), 16);\r\n    const g = parseInt(color.substring(2, 4), 16);\r\n    const b = parseInt(color.substring(4, 6), 16);\r\n\r\n    const brightness = (r * 299 + g * 587 + b * 114) / 1000;\r\n\r\n    return brightness > 128 ? '#000' : '#fff';\r\n  }\r\n  get accentBackground(): string {\r\n    const bg = this.styles?.background;\r\n\r\n    if (!bg) return '';\r\n\r\n    if (bg.accentBackgroundType === 'Solid') {\r\n      return bg.accentColor;\r\n    }\r\n\r\n    const angle = this.getGradientDirection(bg.gradientDirection);\r\n\r\n    return angle\r\n      ? `linear-gradient(${angle}, ${bg.accentColor}, ${bg.secondaryAccentColor})`\r\n      : `linear-gradient(${bg.accentColor}, ${bg.secondaryAccentColor})`;\r\n  }\r\n  getGradientDirection(direction: string | undefined): string {\r\n    switch (direction) {\r\n      case 'DOWN':\r\n        return ''; // default top → bottom (no angle needed)\r\n\r\n      case 'RIGHT':\r\n        return '90deg';\r\n\r\n      case 'DIAGONAL_RIGHT':\r\n        return '45deg';\r\n\r\n      case 'DIAGONAL_LEFT':\r\n        return '135deg';\r\n\r\n      default:\r\n        return ''; // fallback\r\n    }\r\n  }\r\n  increaseQty(item: any) {\r\n    if (!this.edit) {\r\n      item.quantity++;\r\n      this.addToCart(item, item.quantity);\r\n    }\r\n  }\r\n\r\n  decreaseQty(item: any) {\r\n    if (!this.edit) {\r\n      item.quantity--;\r\n      this.addToCart(item, item.quantity);\r\n    }\r\n  }\r\n\r\n  referEarnExist: boolean = false;\r\n  isPointsRedeeming: boolean = false;\r\n  redemptionPoints: any\r\n  checkAppInstalled() {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    this.restService.checkAppInstalled(businessId, 'Refer and Earn').subscribe({\r\n      next: (res: any) => {\r\n        this.referEarnExist = res.data\r\n        this.getRedeemPoints()\r\n      },\r\n      error: (err: any) => {\r\n\r\n      }\r\n    })\r\n  }\r\n\r\n  totalSavingAmt: number = 0\r\n  totalSavingPoints: number = 0\r\n  pointsConverted: number = 0\r\n  usedPoints: any\r\n  getRedeemPoints() {\r\n    let businessId = localStorage.getItem(\"bId\") ?? localStorage.getItem(\"businessId\")\r\n    const userDetails = (this.storageService.getUser() as User);\r\n    let userId = userDetails?.userId\r\n    let orderValue = this.responseData?.billdetails?.totalNetValue\r\n    // let businessId = '1f12df16-8154-6cea-85c5-fb616c47aaf4'\r\n    // let userId = '29d2b424-680c-46bd-b18f-b86b346eb1cf'\r\n    // let orderValue = this.responseData?.billdetails?.totalNetValue\r\n\r\n    this.restService.getRedeemPoints(businessId, userId, 'PRODUCT_PURCHASE', orderValue, true).subscribe({\r\n      next: (res: any) => {\r\n        this.redemptionPoints = res\r\n        this.pointsConverted = res.availablePoints / res.pointsConvertedRupees;\r\n        this.totalSavingAmt = this.getRemainingRupees\r\n        this.totalSavingPoints = this.getRemainingPoints\r\n        this.usedPoints = this.getRemainingRupees * this.pointsConverted;\r\n      },\r\n      error: (err: any) => {\r\n\r\n      }\r\n    })\r\n  }\r\n\r\n  onPointsRedeemingChange(event: Event) {\r\n    if (this.appliedVoucher) {\r\n      event.preventDefault();\r\n      this.messageService.add({\r\n        severity: 'info',\r\n        summary: 'Points Redeem',\r\n        detail: 'You can not redeem points when a coupon is applied. Please remove the coupon to redeem points'\r\n      });\r\n    } else {\r\n      this.isPointsRedeeming = !this.isPointsRedeeming;\r\n    }\r\n  }\r\n\r\n  // For repemption\r\n  get getRemainingPoints() {\r\n    return this?.responseData?.totalAmount > this?.redemptionPoints.pointsConvertedRupees ? 0 : (this?.redemptionPoints.availablePoints - this?.responseData?.totalAmount * this.pointsConverted)\r\n  }\r\n\r\n  get getRemainingRupees() {\r\n    return this?.responseData?.totalAmount > this?.redemptionPoints?.pointsConvertedRupees ? this?.redemptionPoints?.pointsConvertedRupees : this?.responseData?.totalAmount\r\n  }\r\n\r\n  paymentWithCompletePoints() {\r\n    let cartId = localStorage.getItem('cartId')\r\n    let payload = {\r\n      rewardUsed: this?.isPointsRedeeming ? \"REWARD_POINTS\" : this?.appliedVoucher ? \"VOUCHER\" : null,\r\n      pointsUsed: this?.isPointsRedeeming ? this.usedPoints : 0,\r\n      pointsConvertedINR: this?.isPointsRedeeming ? this.totalSavingAmt : 0,\r\n      voucherValue: this.selectedVoucherAmount ? this.selectedVoucherAmount : this.percentageReduced ? this.percentageReduced : 0,\r\n      voucherId: this?.appliedVoucher ? this.selectedVoucherId : null,\r\n      voucherCode: this?.appliedVoucher ? this.selectedVoucherCode : '',\r\n    }\r\n    this.restService.paymentWithCompletePoints(cartId, payload).subscribe({\r\n      next: (res: any) => {\r\n        localStorage.removeItem(\"orderId\");\r\n        localStorage.removeItem(\"cartId\");\r\n        localStorage.removeItem(\"paymentFor\");\r\n        this.storageService.clearUserCart();\r\n        Swal.fire({\r\n          icon: \"success\",\r\n          title: \"Hurray\",\r\n          text: \"Order placed successfully\",\r\n          confirmButtonText: \"See Details\"\r\n        }).then((response) => {\r\n          if (response.isConfirmed) {\r\n            this.router.navigate(['/profile']);\r\n          }\r\n        })\r\n      },\r\n      error: (err: any) => {\r\n        this.messageService.add({ severity: 'error', summary: 'Order Failed', detail: 'Failed to place order' });\r\n      }\r\n    })\r\n  }\r\n\r\n}\r\n","<ng-container *ngIf=\"!isLoading\">\r\n  <p-toast position=\"bottom-right\" [baseZIndex]=\"10000000000\" [autoZIndex]=\"true\"\r\n    [showTransformOptions]=\"isMobile ? 'translateY(-100%)' : ''\"></p-toast>\r\n\r\n  <ng-container *ngIf=\"data\">\r\n    <section [id]=\"data?.id\" [simpoLayout]=\"styles?.layout\" [id]=\"data?.id\"\r\n      [attr.class]=\"isMobile ? 'py-5 position-relative' : 'position-relative'\" simpoHover\r\n      (hovering)=\"showEditTabs($event)\" [attr.style]=\"customClass\"\r\n      [ngClass]=\"!responseData?.orderedItems?.length ? 'no-items' : ''\">\r\n      <div class=\"d-flex align-items-center justify-content-center m-auto mb-4\"\r\n        [style.marginTop.px]=\"isMobile ? '': '50'\" [style.width.%]=\"isMobile ? '90' : ''\"\r\n        *ngIf=\"responseData?.orderedItems?.length && currentTab === 'ADDRESS'\">\r\n        <span class=\"timeline\" (click)=\"currentTab = 'BAG'\">Bag</span>\r\n        <div class=\"bar\"></div>\r\n        <span class=\"timeline isActive\">Address</span>\r\n        <div class=\"bar\"></div>\r\n        <span class=\"timeline\" style=\"cursor: auto;\">Payment</span>\r\n      </div>\r\n      <div class=\"cart-tab-parent w-100\" *ngIf=\"currentTab == 'BAG' && ecomConfigs?.appointmentBookingEnabled\">\r\n        <!-- && ecomConfigs?.appointmentBookingEnabled\" -->\r\n        <div class=\"cart-tabs\" [id]=\"data?.id\">\r\n          <div class=\"selected-cart-tab\" [ngClass]=\"{'selected-cart-tab': cartType==='SHOPPING'}\"\r\n            (click)=\"cartType='SHOPPING'\">Shopping Cart ({{responseData?.orderedItems?.length ?? 0}})</div>\r\n          <div [ngClass]=\"{'selected-cart-tab': cartType==='TRIAL'}\" (click)=\"cartType='TRIAL'\">Trial Cart\r\n            ({{trialCartItem?.length ?? 0}})</div>\r\n        </div>\r\n      </div>\r\n      <div class=\"cart-parent\" [spacingHorizontal]=\"stylesLayout\" *ngIf=\"currentTab === 'BAG'\" [id]=\"data?.id\"\r\n        [simpoAnimation]=\"styles?.animation\">\r\n        <ng-container>\r\n          <ng-container *ngIf=\"cartType === 'SHOPPING'\">\r\n            <ng-container\r\n              *ngTemplateOutlet=\"(responseData?.orderedItems?.length || 0) > 0 ? CARTPAGE : EMPTYITEM\"></ng-container>\r\n          </ng-container>\r\n          <ng-container *ngIf=\"cartType === 'TRIAL'\">\r\n            <ng-container *ngTemplateOutlet=\"(trialCartItem?.length || 0) > 0 ? CARTPAGE : EMPTYITEM\"></ng-container>\r\n          </ng-container>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"d-flex checkoutPage\"\r\n        *ngIf=\"(responseData?.orderedItems?.length || 0) > 0 && currentTab === 'ADDRESS'\">\r\n        <ng-container *ngTemplateOutlet=\"CHECKOUTPAGE\">\r\n        </ng-container>\r\n      </div>\r\n\r\n\r\n      <div [ngClass]=\"{'hover_effect': edit}\" *ngIf=\"showEditors\">\r\n        <simpo-hover-elements [data]=\"data\" [index]=\"index\" [editOptions]=\"edit\"\r\n          [isEcommerce]=\"true\"></simpo-hover-elements>\r\n      </div>\r\n      <div *ngIf=\"showDelete\" [ngClass]=\"{'hover_effect': delete}\">\r\n        <simpo-delete-hover-element [data]=\"data\" [index]=\"index\"></simpo-delete-hover-element>\r\n      </div>\r\n\r\n    </section>\r\n  </ng-container>\r\n  <ng-container *ngIf=\"!data\">\r\n    <section class=\"cart-window\">\r\n      <div class=\"heading-large lh-2 mb-3 header-sec\">\r\n        <div class=\"d-flex align-items-center\">\r\n          <mat-icon (click)=\"closeWindow()\">keyboard_arrow_left</mat-icon>\r\n          <span>Your Cart</span>\r\n        </div>\r\n        <div class=\"saving\"></div>\r\n      </div>\r\n      <div class=\"offers\">\r\n        <div class=\"d-flex align-items-center\" style=\"gap: 5px;\">\r\n          <img src=\"https://i.postimg.cc/htY55sqY/discount.png\" alt=\"\" height=\"20\" width=\"20\">\r\n          <span>Avail Offers / Coupons</span>\r\n        </div>\r\n        <mat-icon>keyboard_arrow_right</mat-icon>\r\n      </div>\r\n      <div class=\"small-items\">\r\n        <ng-container *ngFor=\"let item of responseData?.orderedItems\">\r\n          <div class=\"small-item\">\r\n            <div class=\"d-flex\" style=\"gap: 5px;\">\r\n              <div class=\"h-100\" style=\"padding: 0px; width: fit-content;\">\r\n                <img loading=\"lazy\" onerror=\"this.src='https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\"\r\n                  class=\"small-product-img\"\r\n                  [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" alt=\"\"\r\n                  (click)=\"goToProductDetails(item)\">\r\n              </div>\r\n              <div class=\"small-item-name trim-text\">{{ item.itemName | titlecase }}</div>\r\n              <div class=\"small-item-quantity\">\r\n                <span class=\"cursor\">-</span>\r\n                <span>{{item.quantity}}</span>\r\n                <span class=\"cursor\">+</span>\r\n              </div>\r\n              <div class=\"small-item-price\">\r\n                <div class=\"price-with-tax\">\r\n                  <span [innerHTML]='currency'></span> {{(item.sellingPrice) | number: '1.0-2'}}\r\n                </div>\r\n                <!-- <div class=\"price-with-tax\">\r\n                  <span [innerHTML]='currency'></span> {{(item.selling) | number: '1.0-2'}}\r\n                </div> -->\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </ng-container>\r\n      </div>\r\n      <div class=\"fotter-sec\">\r\n        <div class=\"delivery-add d-flex\">\r\n          <mat-icon>home</mat-icon>\r\n          <div class=\"address\">Tetsting</div>\r\n        </div>\r\n        <button class=\"payment-btn\" [disabled]=\"cartInfo.addressDetails\" (click)=\"proceedToCheckout()\"> <span\r\n            style=\"margin-right: 5px;\">Click to Pay</span> <span [innerHtml]='currency'></span>\r\n          {{(responseData?.totalAmount ?? 0) | number: '1.0-2'}}</button>\r\n      </div>\r\n    </section>\r\n  </ng-container>\r\n</ng-container>\r\n\r\n<ngx-skeleton-loader *ngIf=\"isLoading\" count=\"1\" appearance=\"circle\" [theme]=\"{\r\n  width: '100%',\r\n  height: '40vh',\r\n  'border-radius': '10px',\r\n  'position': 'relative',\r\n  'right': '5px'\r\n}\">\r\n</ngx-skeleton-loader>\r\n\r\n<ng-template #CouponList>\r\n  <section class=\"coupons-listing-section\">\r\n    <div class=\"coupon-heading\">\r\n      <div class=\"back-btn\" (click)=\"closeDialogRef()\">\r\n        <mat-icon>keyboard_arrow_left</mat-icon>\r\n      </div>\r\n      <div class=\"header-text\">Apply Coupon</div>\r\n    </div>\r\n    <!-- <div class=\"coupon-search-sec\">\r\n      <input type=\"text\" placeholder=\"Type Coupon Code\" [(ngModel)]=\"enteredCouponCode\">\r\n      <div class=\"apply-btn-search\" (click)=\"searchIfApplicable()\">Apply</div>\r\n    </div> -->\r\n    <div class=\"coupon-listing\">\r\n      <ng-container *ngIf=\"couponList.length > 0; else showEmptyScreen\">\r\n        <ng-container *ngFor=\"let couponDetails of couponList; let idx = index\">\r\n          <div class=\"coupon-details\"\r\n            [ngStyle]=\"{'background-color': !couponDetails.applicable ? '#FFF2F4' : '#EDFFFA'}\"\r\n            *ngIf=\"couponDetails?.status\">\r\n            <div class=\"details__coupon-heading\">\r\n              <div class=\"coupon-brief\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name\" [ngStyle]=\"{'color': !couponDetails.applicable ? '#DB1A1A' : '#097D5F'}\">\r\n                    {{ couponDetails.couponCode | uppercase }}</div>\r\n                  <div class=\"coupon-desc\">{{ couponDetails.discountDescription | titlecase }}</div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn\" [style.opacity]=\"couponDetails.applicable ? '1' : '0.3'\"\r\n                    [ngStyle]=\"{'cursor': couponDetails.applicable ? 'pointer' : ''}\"\r\n                    (click)=\"applyCoupon(couponDetails)\">Apply</div>\r\n                </div>\r\n              </div>\r\n              <!-- <div class=\"coupon-toggle-details-btn\" (click)=\"couponDetails.status = !couponDetails.status\">\r\n                <span class=\"hide-details-btn\" *ngIf=\"couponDetails.status\">Hide details</span>\r\n                <div class=\"show-details-btn\" *ngIf=\"!couponDetails.status\">View details</div>\r\n              </div> -->\r\n            </div>\r\n            <ng-container>\r\n              <!-- *ngIf=\"couponDetails.status\" -->\r\n              <div class=\"details-divider\"></div>\r\n              <ul class=\"details__coupon-terms\">\r\n                <li>Offer valid from {{ couponDetails.validFrom | date }} - {{ couponDetails.validTo | date }}</li>\r\n              </ul>\r\n            </ng-container>\r\n          </div>\r\n        </ng-container>\r\n      </ng-container>\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Coupon Available</div>\r\n          <div class=\"empty-screen__secondary-text\">\r\n            Looks like there are no coupons at the moment\r\n          </div>\r\n          <!-- <div class=\"empty-screen__button\">Explore</div> -->\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #RedemptionVouchers>\r\n  <section class=\"vouchers-listing-section d-flex flex-column\">\r\n    <div class=\"coupon-heading d-flex align-items-center gap-2 p-3 fs-18 fw-600 border-bottom\">\r\n      <div class=\"back-btn cursor-pointer d-flex align-items-center\" (click)=\"closeDialogRef()\">\r\n        <mat-icon>keyboard_arrow_left</mat-icon>\r\n      </div>\r\n      <div class=\"header-text\">Coupons & Vouchers</div>\r\n    </div>\r\n\r\n    <!-- <div class=\"d-flex align-items-center tab-container justify-content-between gap-2 p-3\">\r\n      <div class=\"redemption-type fs-16 fw-500 cursor-pointer\" [ngClass]=\"{'active-type': redemptionType === 'COUPONS'}\"\r\n        (click)=\"redemptionType = 'COUPONS'\">\r\n        Coupons\r\n      </div>\r\n      <div class=\"redemption-type fs-16 fw-500 cursor-pointer\" [ngClass]=\"{'active-type': redemptionType === 'VOUCHERS'}\"\r\n        (click)=\"redemptionType = 'VOUCHERS'\">\r\n        Vouchers\r\n      </div>\r\n    </div> -->\r\n\r\n    <div class=\"coupon-listing d-flex flex-column gap-3 pt-3\" *ngIf=\"redemptionType === 'COUPONS'\">\r\n      <div class=\"d-flex align-items-center tab-container gap-3\">\r\n        <div class=\"coupon-type fs-16 fw-500 cursor-pointer\"\r\n          [ngClass]=\"{'active-coupon': redemptionCouponType === 'REWARDS'}\" (click)=\"redemptionCouponType = 'REWARDS'\">\r\n          Rewards\r\n        </div>\r\n        <div class=\"coupon-type fs-16 fw-500 cursor-pointer\"\r\n          [ngClass]=\"{'active-coupon': redemptionCouponType === 'DISCOUNTS'}\"\r\n          (click)=\"redemptionCouponType = 'DISCOUNTS'\">\r\n          Discounts\r\n        </div>\r\n      </div>\r\n      <ng-container *ngIf=\"redemptionCouponType === 'REWARDS'\">\r\n        <ng-container *ngIf=\"(listRedemptionCoupons?.vouchers?.length > 0) ; else showEmptyScreen\">\r\n          <ng-container *ngFor=\"let voucher of listRedemptionCoupons?.vouchers; let idx = index\">\r\n            <div class=\"voucher-details\" *ngIf=\"!voucher.utilised\">\r\n\r\n              <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name fs-16 fw-600 mb-1\">{{ voucher.voucherName }}</div>\r\n                  <div class=\"coupon-desc fs-12 text-secondary\">\r\n                    Get {{ voucher.couponValueType === 'FIXED' ? '₹' + voucher.couponValue : voucher.couponValue + '%'\r\n                    }}\r\n                    off on your payment\r\n                  </div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\" (click)=\"applyRedemptionCoupon(voucher)\">\r\n                    Apply</div>\r\n                </div>\r\n              </div>\r\n\r\n              <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n                <div class=\"code-label\">Code</div>\r\n                <div class=\"code-value\">{{ voucher.voucherCode }}</div>\r\n              </div>\r\n\r\n              <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n                <span class=\"min-order\">Min: ₹{{ voucher.minOrderValue | number }}</span>\r\n                <span class=\"separator text-secondary\">|</span>\r\n                <span class=\"validity\">\r\n                  <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                  Until {{ voucher.issuedDate | date: 'MMM dd, yyyy' }}\r\n                </span>\r\n                <span class=\"separator text-secondary\" *ngIf=\"voucher.maxRedeemableAmount\">|</span>\r\n                <span class=\"min-order\" *ngIf=\"voucher.maxRedeemableAmount\">Max Redeemable Amount: ₹{{\r\n                  voucher.maxRedeemableAmount | number }}</span>\r\n              </div>\r\n\r\n              <!-- <div class=\"terms-link\">View terms & conditions</div> -->\r\n            </div>\r\n          </ng-container>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-container *ngIf=\"redemptionCouponType === 'DISCOUNTS'\">\r\n        <ng-container *ngIf=\"(couponList.length > 0); else showEmptyDiscounts\">\r\n          <ng-container *ngFor=\"let couponDetails of couponList; let idx = index\">\r\n            <div class=\"voucher-details\" *ngIf=\"couponDetails?.status\">\r\n\r\n              <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n                <div class=\"coupon-brief__left-sec\">\r\n                  <div class=\"coupon-name fs-16 fw-600 mb-1\"\r\n                    [ngStyle]=\"{'color': !couponDetails.applicable ? '#DB1A1A' : '#097D5F'}\">\r\n                    {{ couponDetails.couponCode | uppercase }}\r\n                  </div>\r\n                  <div class=\"coupon-desc fs-12 text-secondary\">\r\n                    {{ couponDetails.discountDescription | titlecase }}\r\n                  </div>\r\n                </div>\r\n                <div class=\"coupon-brief__right-sec\">\r\n                  <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\"\r\n                    [style.opacity]=\"couponDetails.applicable ? '1' : '0.3'\"\r\n                    [ngStyle]=\"{'cursor': couponDetails.applicable ? 'pointer' : 'not-allowed'}\"\r\n                    (click)=\"applyCoupon(couponDetails)\">\r\n                    Apply\r\n                  </div>\r\n                </div>\r\n              </div>\r\n\r\n              <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n                <div class=\"code-label\">Code</div>\r\n                <div class=\"code-value\">{{ couponDetails.couponCode | uppercase }}</div>\r\n              </div>\r\n\r\n              <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n                <span class=\"validity\">\r\n                  <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                  {{ couponDetails.validFrom | date }} - {{ couponDetails.validTo | date }}\r\n                </span>\r\n              </div>\r\n\r\n            </div>\r\n          </ng-container>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-template #showEmptyDiscounts>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Discount Coupons Available</div>\r\n          <div class=\"empty-screen__secondary-text\">\r\n            Looks like there are no discount coupons at the moment\r\n          </div>\r\n          <!-- <div class=\"empty-screen__button\">Explore</div> -->\r\n        </div>\r\n      </ng-template>\r\n\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Coupons Available</div>\r\n          <div class=\"empty-screen__secondary-text\">Looks like there are no coupons</div>\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n\r\n    <div class=\"coupon-listing d-flex flex-column gap-3\" *ngIf=\"redemptionType === 'VOUCHERS'\">\r\n      <ng-container *ngIf=\"listRedemptionVouchers?.vouchers?.length > 0; else showEmptyScreen\">\r\n        <ng-container *ngFor=\"let voucher of listRedemptionVouchers?.vouchers; let idx = index\">\r\n          <div class=\"voucher-details\" *ngIf=\"!voucher.utilised\">\r\n\r\n            <div class=\"coupon-brief d-flex justify-content-between align-items-start mb-3\">\r\n              <div class=\"coupon-brief__left-sec\">\r\n                <div class=\"coupon-name fs-16 fw-600 mb-1\">{{ voucher.voucherName }}</div>\r\n                <div class=\"coupon-desc fs-12 text-secondary\">\r\n                  Get {{ voucher.couponValueType === 'FIXED' ? '₹' + voucher.couponValue : voucher.couponValue + '%' }}\r\n                  off on your payment\r\n                </div>\r\n              </div>\r\n              <div class=\"coupon-brief__right-sec\">\r\n                <div class=\"apply-offer-btn fs-12 fw-600 cursor-pointer\" (click)=\"applyRedemptionCoupon(voucher)\">Apply\r\n                </div>\r\n              </div>\r\n            </div>\r\n\r\n            <div class=\"coupon-code-box d-flex align-items-center gap-3\">\r\n              <div class=\"code-label\">Code</div>\r\n              <div class=\"code-value\">{{ voucher.voucherCode }}</div>\r\n            </div>\r\n\r\n            <div class=\"coupon-meta d-flex align-items-center gap-2 fs-12 text-secondary mb-2\">\r\n              <span class=\"min-order\">Min: ₹{{ voucher.minOrderValue | number }}</span>\r\n              <span class=\"separator text-secondary\">|</span>\r\n              <span class=\"validity\">\r\n                <mat-icon class=\"clock-icon\">schedule</mat-icon>\r\n                Until {{ voucher.issuedDate | date: 'MMM dd, yyyy' }}\r\n              </span>\r\n            </div>\r\n\r\n            <!-- <div class=\"terms-link\">View terms & conditions</div> -->\r\n          </div>\r\n        </ng-container>\r\n      </ng-container>\r\n\r\n      <ng-template #showEmptyScreen>\r\n        <div class=\"empty-screen-container\">\r\n          <img loading=\"lazy\" src=\"../../../../../assets/common/coupon-empty-img.svg\" alt=\"\">\r\n          <div class=\"empty-screen__primary-text\">No Vouchers Available</div>\r\n          <div class=\"empty-screen__secondary-text\">Looks like there are no vouchers</div>\r\n        </div>\r\n      </ng-template>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #CARTPAGE>\r\n  <div class=\"container\">\r\n    <div class=\"main-content\">\r\n      <div class=\"promo-banner mb-3\" [id]=\"data?.id\" *ngIf=\"cartType === 'SHOPPING' && ecomConfigs?.videoCallEnabled\">\r\n        <!-- && ecomConfigs?.videoCallEnabled\" -->\r\n        <div class=\"promo-text\">\r\n          <h3>See It Before You Buy It</h3>\r\n          <p>Experience our designs in detail via video call</p>\r\n        </div>\r\n        <button class=\"see-live-btn\" (click)=\"scheduleVideoCall(responseData?.orderedItems)\">\r\n          <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"16\" height=\"16\" viewBox=\"0 0 24 24\" fill=\"none\"\r\n            stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"\r\n            class=\"lucide lucide-video\">\r\n            <path d=\"m22 8-6 4 6 4V8Z\" />\r\n            <rect width=\"14\" height=\"12\" x=\"2\" y=\"6\" rx=\"2\" ry=\"2\" />\r\n          </svg>\r\n          SEE IT LIVE\r\n        </button>\r\n      </div>\r\n\r\n      <div class=\"cart-items\">\r\n        <div class=\"cart-header\">\r\n          <h2>Your Cart</h2>\r\n        </div>\r\n        <ng-container\r\n          *ngTemplateOutlet=\"CARTITEM;context:{data: cartType === 'SHOPPING' ? responseData?.orderedItems : trialCartItem}\"></ng-container>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"sidebar\">\r\n      <div class=\"reedem-section d-flex flex-column align-items-center\" *ngIf=\"cartType != 'TRIAL' && getUrl()\">\r\n        <div class=\"justify-content-between d-flex align-items-center w-100 redeem-section-text\">Redeem Section Amount\r\n          <div class=\"toogle-switch\">\r\n            <div class=\"form-check form-switch\">\r\n              <input class=\"form-check-input cursor-pointer\" type=\"checkbox\" role=\"switch\" id=\"flexSwitchCheckChecked\"\r\n                [checked]=\"selectMatureScheme\" (change)=\"onToggleChange()\">\r\n            </div>\r\n          </div>\r\n        </div>\r\n        <!-- <div class=\"select_matured_text  w-100 text-start cursor-pointer\"\r\n          *ngIf=\"selectMatureScheme && !selectedRedemption\" (click)=\"selectScheme()\">\r\n          Select Matured Scheme\r\n        </div> -->\r\n        <!-- <div class=\"select_matured_text d-flex flex-column gap-2 w-100 text-start cursor-pointer\"\r\n          *ngIf=\"selectedRedemption\">\r\n          Selected Scheme\r\n          <div class=\"d-flex w-100 justify-content-between align-items-center group_invest\">Group Investment\r\n            scheme-5000/M <span>Change</span></div>\r\n          <div class=\"d-flex justify-content-between align-items-center w-100 redeem_amount\">Redeemable Amount\r\n            <span>₹{{selectedRedmpationData.selectedAmount}}</span>\r\n          </div>\r\n        </div> -->\r\n      </div>\r\n      <div class=\"scheme-section\" *ngIf=\"selectMatureScheme\">\r\n        <ng-container *ngTemplateOutlet=\"SCHEME_REDEMPTION\"></ng-container>\r\n      </div>\r\n      <div class=\"coupon-section\" [id]=\"data?.id\" *ngIf=\"cartType === 'SHOPPING' && !referEarnExist\"\r\n        (click)=\"openDialog(CouponList)\">\r\n        <div class=\"coupon-left\">\r\n          <div class=\"coupon-icon\"><mat-icon>percent</mat-icon></div>\r\n          <span class=\"coupon-text\" *ngIf=\"!responseData.billdetails?.couponId\">Apply\r\n            Coupon</span>\r\n          <span class=\"coupon-text\" *ngIf=\"responseData.billdetails?.couponId\">Coupon\r\n            Applied</span>\r\n        </div>\r\n        <svg *ngIf=\"!responseData.billdetails?.couponId\" xmlns=\"http://www.w3.org/2000/svg\" width=\"14\" height=\"14\"\r\n          viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2.5\" stroke-linecap=\"round\"\r\n          stroke-linejoin=\"round\" class=\"chevron-icon\">\r\n          <path d=\"m9 18 6-6-6-6\" />\r\n        </svg>\r\n        <span *ngIf=\"responseData.billdetails?.couponId\"\r\n          (click)=\"removeCoupon($event)\"><mat-icon>close</mat-icon></span>\r\n      </div>\r\n\r\n      <div class=\"plan-details-container p-3 rounded-4 bg-white text-dark voucher-details\"\r\n        *ngIf=\"referEarnExist && this?.redemptionPoints?.availablePoints > 0\">\r\n        <div class=\"fs-14 fw-500\">\r\n          Rewards Available\r\n        </div>\r\n        <div class=\"d-flex justify-content-between align-items-start border-bottom pb-2\">\r\n          <div class=\"avb_pts mt-2 mb-2\">\r\n            <span class=\"fs-16 fw-500 total_points text-secondary\">\r\n              <span class=\" fs-18 fw-600 text-dark\">{{(this?.redemptionPoints?.availablePoints || 0).toFixed(2)}}</span>\r\n              pts\r\n            </span>\r\n            <div class=\"total_value fs-12 text-secondary\">\r\n              = max ₹{{(this?.redemptionPoints?.pointsConvertedRupees || 0).toFixed(2)}} discount\r\n            </div>\r\n          </div>\r\n          <div class=\"wallte_icon\">\r\n            <img src=\"https://d2z9497xp8xb12.cloudfront.net/prod-images/777779c1775200561187wallet_(1).png\" alt=\"\">\r\n          </div>\r\n        </div>\r\n        <div class=\"d-flex justify-content-between align-items-center mt-3\">\r\n          <div class=\"redemable_text\">\r\n            <div class=\"title_text\">\r\n              <div class=\"fs-14 fw-500\">\r\n                Redeem Points\r\n              </div>\r\n              <div class=\"fs-13 fs-400\">\r\n                Use your points for discount\r\n              </div>\r\n            </div>\r\n          </div>\r\n          <div class=\"toggle_btn\">\r\n            <label class=\"switch\">\r\n              <input type=\"checkbox\" id=\"toggleSwitch\" [checked]=\"isPointsRedeeming\"\r\n                (click)=\"onPointsRedeemingChange($event)\" />\r\n              <span class=\"slider\"></span>\r\n            </label>\r\n          </div>\r\n        </div>\r\n        <div class=\"mt-3 success_selected w-100 applied-coupon-card\" *ngIf=\"isPointsRedeeming\">\r\n          <div class=\"d-flex align-items-start gap-2\">\r\n            <div class=\"success_icon\">\r\n              <mat-icon class=\"d-flex justify-content-center align-items-center text-success\">check_circle</mat-icon>\r\n            </div>\r\n            <div class=\"success_text\">\r\n              <div class=\"fs-13 fw-500\">\r\n                You're saving ₹\r\n                {{totalSavingAmt || 0}}\r\n              </div>\r\n              <div class=\"fs-12 fs-400 text-success\">\r\n                {{totalSavingPoints}} points remaining after redemption\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n\r\n      <!-- Existing coupon row (keep as-is) -->\r\n      <div class=\"coupon-section d-flex flex-column voucher-details\" [id]=\"data?.id\"\r\n        *ngIf=\"cartType === 'SHOPPING' && referEarnExist\">\r\n        <div class=\"d-flex justify-content-between align-items-center w-100\">\r\n          <div class=\"coupon-left\">\r\n            Apply Coupon\r\n          </div>\r\n          <div (click)=\"addRedemptionCoupon(RedemptionVouchers)\">View All</div>\r\n        </div>\r\n\r\n        <!-- Applied Coupon Success Banner -->\r\n        <div class=\"applied-coupon-card w-100 mt-3 d-flex align-items-center justify-content-between\"\r\n          *ngIf=\"selectedVoucherId\">\r\n          <div class=\"applied-coupon-left d-flex align-items-center gap-3\">\r\n            <mat-icon class=\"success-check\">check_circle</mat-icon>\r\n            <div class=\"applied-coupon-info\">\r\n              <div class=\"applied-coupon-code\">Coupon {{ selectedVoucherCode }} applied!</div>\r\n              <div class=\"applied-coupon-saving\">You're saving\r\n                <span *ngIf=\"this.couponValueType === 'AMOUNT'\">₹ {{selectedVoucherAmount || 0}}</span>\r\n                <span *ngIf=\"this.couponValueType === 'PERCENTAGE'\"> {{selectedVoucherPercentage || 0}}%</span>\r\n              </div>\r\n\r\n            </div>\r\n          </div>\r\n          <div class=\"remove-coupon-btn fs-14 fw-500 text-secondary cursor-pointer\"\r\n            (click)=\"removeRedemptionCoupon($event)\">Remove</div>\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"delivery-section\" *ngIf=\"getUrl()\">\r\n        <div class=\"delivery-header\">\r\n          <mat-icon>gps_fixed</mat-icon>\r\n          <span *ngIf=\"cartType === 'SHOPPING'\">Delivering to</span>\r\n          <span *ngIf=\"cartType === 'TRIAL'\">Trial Location at</span>\r\n          <span class=\"pincode\">{{pincode}}</span>\r\n          <!-- <a class=\"change-link\">Change Pincode</a> -->\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"summary-section\">\r\n        <div class=\"summary-title\">Summary</div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Subtotal</span>\r\n          <span class=\"summary-value\">₹{{(responseData?.billdetails?.totalNetValue ?? 0) | number: '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING' && referEarnExist && isPointsRedeeming\">\r\n          <span class=\"summary-label\">Points Redeemed</span>\r\n          <span class=\"summary-value\">- ₹{{ totalSavingAmt || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\"\r\n          *ngIf=\"cartType === 'SHOPPING' && referEarnExist && (this.couponValueType === 'AMOUNT' && appliedVoucher)\">\r\n          <span class=\"summary-label\">Voucher Applied</span>\r\n          <span class=\"summary-value\">- ₹{{ selectedVoucherAmount || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\"\r\n          *ngIf=\"cartType === 'SHOPPING' && referEarnExist && (this.couponValueType === 'PERCENTAGE' && appliedVoucher)\">\r\n          <span class=\"summary-label\">Voucher Applied</span>\r\n          <span class=\"summary-value\">- ₹{{ percentageReduced || 0 }}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Shipping</span>\r\n          <span class=\"summary-value\"\r\n            [ngClass]=\"{'savings': !responseData?.billdetails?.deliveryCharges || responseData.billdetails.deliveryCharges <= 0}\">\r\n            {{ (responseData?.billdetails?.deliveryCharges && responseData.billdetails.deliveryCharges > 0) ? ('₹' +\r\n            (responseData.billdetails.deliveryCharges | number: '1.0-2')) : 'Free' }}\r\n          </span>\r\n        </div>\r\n\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Estimated Tax</span>\r\n          <span class=\"summary-value\">₹{{((!responseData.billdetails?.couponId ?\r\n            responseData?.billdetails?.totalTax : responseData?.billdetails?.totalTaxAfterDiscount) ?? 0) |\r\n            number: '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"summary-row total-row\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span class=\"summary-label\">Total</span>\r\n          <!-- <span class=\"summary-value\">₹{{ responseData?.totalAmount | number: '1.0-2' }}</span> -->\r\n          <span class=\"total-value\" *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{ responseData?.totalAmount |\r\n            number: '1.0-2' }}</span>\r\n\r\n          <span class=\"total-value\" *ngIf=\"isPointsRedeeming\">₹{{ (responseData?.totalAmount - (totalSavingAmt || 0)) |\r\n            number: '1.0-2' }}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (percentageReduced || 0)) | number:\r\n            '1.0-2' }}</span>\r\n        </div>\r\n\r\n        <!-- Trial Cart Summary -->\r\n        <ng-container *ngIf=\"cartType === 'TRIAL'\">\r\n          <div class=\"summary-row\">\r\n            <span class=\"summary-label\">Free Trial</span>\r\n            <span class=\"summary-value\">₹0</span>\r\n          </div>\r\n          <div class=\"summary-row\">\r\n            <span class=\"summary-label\">Service Charge</span>\r\n            <span class=\"summary-value savings\">Free</span>\r\n          </div>\r\n          <div class=\"summary-divider\"></div>\r\n          <div class=\"summary-row total-row\">\r\n            <span class=\"summary-label\">Total</span>\r\n            <span class=\"summary-value\">₹0</span>\r\n          </div>\r\n          <!-- <span class=\"total-value\" *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{ responseData?.totalAmount |\r\n            number: '1.0-2' }}</span>\r\n\r\n          <span class=\"total-value\" *ngIf=\"isPointsRedeeming\">₹{{ (responseData?.totalAmount - (totalSavingAmt || 0)) |\r\n            number: '1.0-2' }}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (percentageReduced || 0)) | number:\r\n            '1.0-2' }}</span> -->\r\n        </ng-container>\r\n      </div>\r\n      <button class=\"place-order-btn\" (click)=\"edit ? '' : proceedToListPage()\" simpoButtonDirective\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        *ngIf=\"cartType === 'SHOPPING'\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[1]?.content?.label ?? 'Continue\r\n        Shopping'}}</button>\r\n      <button class=\"place-order-btn mt-0\" (click)=\"edit ? '' : proceedToCheckout()\" simpoButtonDirective\r\n        *ngIf=\"cartType === 'SHOPPING'\" [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\"\r\n        [color]=\"data?.styles?.background?.accentColor\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[0]?.content?.label ?? 'Checkout\r\n        Cart'}}</button>\r\n      <button class=\"place-order-btn mt-0\" simpoButtonDirective *ngIf=\"cartType === 'TRIAL'\"\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\" [backgroundInfo]=\"styles?.background\" (click)=\"bookAppointment()\">BOOK\r\n        APPOINTMENT</button>\r\n\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n<ng-template #CHECKOUTPAGE>\r\n  <div class=\"checkout-left-panel\">\r\n    <div class=\"checkout-main-content\">\r\n      <!-- <div class=\"delivery-options\">\r\n        <div class=\"delivery-option active\">\r\n          <div class=\"delivery-icon\"></div>\r\n          HOME DELIVERY\r\n        </div>\r\n        <div class=\"delivery-option\">\r\n          <div class=\"delivery-icon\"></div>\r\n          STORE PICK-UP\r\n        </div>\r\n      </div> -->\r\n\r\n      <div class=\"section-title\">Shipping Address</div>\r\n\r\n      <div class=\"shipping-info\" *ngIf=\"defaultAddress\">\r\n        <div class=\"address-info\">\r\n          <div class=\"address-name\">{{defaultAddress?.receiverName}} ({{defaultAddress?.addressType}})</div>\r\n          <div class=\"address-details\">{{defaultAddress?.addressLine1}}, {{defaultAddress?.cityName}},\r\n            {{defaultAddress?.stateName}}</div>\r\n          <div class=\"mobile-number\">Mobile: {{defaultAddress?.receiverPhone}}</div>\r\n        </div>\r\n      </div>\r\n\r\n      <div class=\"addLinks h-100\" *ngIf=\"!defaultAddress\" (click)=\"addAddress()\">\r\n        <mat-icon>add</mat-icon>\r\n      </div>\r\n\r\n      <button class=\"change-address-btn\" (click)=\"changeAddress()\" *ngIf=\"defaultAddress\">CHANGE OR ADD ADDRESS</button>\r\n\r\n      <button class=\"btn w-100 mt-1 payment-btn\" (click)=\"proceedToPayment()\" simpoButtonDirective\r\n        *ngIf=\"defaultAddress && !placeOrderLoader\" [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\"\r\n        [color]=\"data?.styles?.background?.accentColor\" [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">\r\n        Place Order\r\n      </button>\r\n      <button class=\"btn w-100 mt-1 payment-btn\" simpoButtonDirective *ngIf=\"defaultAddress && placeOrderLoader\"\r\n        [buttonStyle]=\"data?.action?.buttons?.[0]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\" [backgroundInfo]=\"styles?.background\">\r\n        Loading...\r\n      </button>\r\n\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"checkout-right-panel\">\r\n    <div class=\"order-summary\">\r\n      <div class=\"summary-title\">Order Summary</div>\r\n\r\n      <div class=\"checkout-product\">\r\n        <div class=\"product-item\" *ngFor=\"let item of responseData?.orderedItems; let idx = index\">\r\n          <img [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" class=\"product-image\"\r\n            alt=\"\">\r\n          <div class=\"product-details\">\r\n            <div class=\"product-name\">{{item.itemName}}</div>\r\n            <div class=\"product-quantity\">Quantity: {{item.quantity}}</div>\r\n            <div class=\"product-price\">₹{{(item.sellingPrice * item.quantity) | number: '1.0-2'}}</div>\r\n          </div>\r\n        </div>\r\n\r\n      </div>\r\n\r\n      <div class=\"price-breakdown\">\r\n        <div class=\"price-row\">\r\n          <span>Total Price</span>\r\n          <span>₹{{(responseData?.billdetails?.totalNetValue\r\n            ?? 0) | number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row\">\r\n          <span>Total Tax</span>\r\n          <span>₹{{((!responseData.billdetails?.couponId ?\r\n            responseData?.billdetails?.totalTax : responseData?.billdetails?.totalTaxAfterDiscount) ?? 0) |\r\n            number:\r\n            '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"summary-row\" *ngIf=\"cartType === 'SHOPPING' && cartInfo?.billdetails?.orraSchemeRedeemedAmount\">\r\n          <span class=\"summary-label\">Redeem Amount</span>\r\n          <span class=\"summary-value\">₹{{(cartInfo?.billdetails?.orraSchemeRedeemedAmount ?? 0) | number:\r\n            '1.0-2'}}</span>\r\n        </div>\r\n\r\n        <div class=\"price-row discount\"\r\n          *ngIf=\"responseData?.billdetails?.discountAmount && subIndustryName != 'Ecommerce Jewellery'\">\r\n          <span>Coupon Discount</span>\r\n          <span>- ₹{{responseData?.billdetails?.discountAmount\r\n            | number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row\"\r\n          *ngIf=\"responseData?.billdetails?.deliveryCharges && responseData.billdetails.deliveryCharges > 0\">\r\n          <span>Delivery Charge</span>\r\n          <span>{{responseData.billdetails.deliveryCharges\r\n            |\r\n            number: '1.0-2'}}</span>\r\n        </div>\r\n        <div class=\"price-row total\" *ngIf=\"cartType === 'SHOPPING'\">\r\n          <span>TOTAL AMOUNT</span>\r\n          <span *ngIf=\"!isPointsRedeeming && !appliedVoucher\">₹{{(responseData?.totalAmount ?? 0) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"isPointsRedeeming\">₹{{(responseData?.totalAmount - (totalSavingAmt || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'AMOUNT'\">₹{{(responseData?.totalAmount -\r\n            (selectedVoucherAmount || 0)) | number:\r\n            '1.0-2'}}</span>\r\n          <span *ngIf=\"appliedVoucher && this.couponValueType === 'PERCENTAGE'\">₹{{(responseData?.totalAmount -\r\n            (responseData?.totalAmount * (selectedVoucherPercentage / 100) || 0)) | number:\r\n            '1.0-2' }}</span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #CARTITEM let-products=\"data\">\r\n  <div class=\"cart-item\" *ngFor=\"let item of products\" [style.color]=\"fontColor\">\r\n    <div class=\"item-left\">\r\n      <div class=\"item-image\">\r\n        <img class=\"item-img\" [src]=\"item.imgUrl ?? 'https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\" alt=\"\"\r\n          (click)=\"goToProductDetails(item)\" style=\"cursor: pointer;\">\r\n      </div>\r\n      <div class=\"item-details\">\r\n        <h3 class=\"item-title\">{{item.itemName}}</h3>\r\n        <div class=\"item-subtitle\" *ngIf=\"item.itemVariant\">\r\n          <span *ngFor=\"let varient of getKeys(item.itemVariant.properties); let last = last\">\r\n            {{ item.itemVariant.properties[varient] | titlecase }}<span *ngIf=\"!last\">, </span>\r\n          </span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n\r\n    <div class=\"item-right\">\r\n      <div class=\"quantity-control\" *ngIf=\"cartType === 'SHOPPING'\">\r\n        <button class=\"qty-btn px-2\" (click)=\"decreaseQty(item)\" [disabled]=\"item.quantity === 1\">\r\n          <mat-icon>remove</mat-icon>\r\n        </button>\r\n        <span class=\"qty-value px-3\">{{item.quantity}}</span>\r\n        <button class=\"qty-btn px-2\" (click)=\"increaseQty(item)\">\r\n          <mat-icon>add</mat-icon>\r\n        </button>\r\n      </div>\r\n\r\n      <div class=\"item-price\">\r\n        ₹{{item.sellingPrice | number: '1.0-2'}}\r\n      </div>\r\n\r\n      <div class=\"delete-btn-circle\" (click)=\"removeItem(item)\">\r\n        <svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"\r\n          stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"lucide lucide-trash-2\">\r\n          <path d=\"M3 6h18\" />\r\n          <path d=\"M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6\" />\r\n          <path d=\"M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2\" />\r\n          <line x1=\"10\" x2=\"10\" y1=\"11\" y2=\"17\" />\r\n          <line x1=\"14\" x2=\"14\" y1=\"11\" y2=\"17\" />\r\n        </svg>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</ng-template>\r\n\r\n<ng-template #EMPTYITEM>\r\n  <section class=\"empty-cart w-100 d-flex align-items-center justify-content-center\">\r\n    <div class=\"empty-cart-container d-flex flex-column\">\r\n      <div class=\"cart-image\">\r\n        <img loading=\"lazy\" onerror=\"this.src='https://i.postimg.cc/hPS2JpV0/no-image-available.jpg'\"\r\n          [src]=\"data?.content?.image?.url\" [alt]=\"data?.content?.image?.altText\" [appImageEditor]=\"edit || false\"\r\n          [imageData]=\"data?.content?.image\" [sectionId]=\"data?.id\">\r\n      </div>\r\n      <div class=\"cart-text content-side\">\r\n        <ng-container *ngFor=\"let text of data?.content?.inputText\">\r\n          <div class=\"d-flex justify-content-center\"\r\n            [ngClass]=\"{'heading-medium': text.label == 'Heading', 'description': text.label == 'Text'}\">\r\n            <simpo-text-editor [(value)]=\"text.value\" [editable]=\"edit || false\"></simpo-text-editor>\r\n          </div>\r\n        </ng-container>\r\n      </div>\r\n      <button class=\"place-order-btn mx-auto w-fit\" (click)=\"edit ? '' : proceedToListPage()\" simpoButtonDirective\r\n        [buttonStyle]=\"data?.action?.buttons?.[1]?.styles\" [color]=\"data?.styles?.background?.accentColor\"\r\n        [appButtonEditor]=\"edit ?? false\"\r\n        [backgroundInfo]=\"styles?.background\">{{data?.action?.buttons?.[1]?.content?.label ?? 'Continue\r\n        Shopping'}}</button>\r\n    </div>\r\n  </section>\r\n</ng-template>\r\n\r\n<ng-template #SCHEME_REDEMPTION>\r\n  <div class=\"modal-body\">\r\n    <div class=\"scheme-option\" *ngFor=\"let scheme of schemeList\" (click)=\"redeemScheme(scheme, false)\"\r\n      [style.borderColor]=\"cartInfo.billdetails.orraSchemeCode ? styles?.background?.color : ''\">\r\n      <label for=\"individual\" class=\"scheme-card\">\r\n        <div class=\"scheme-info d-flex gap-1\">\r\n          <div class=\"form-check-radio\">\r\n            <input class=\"form-check-input-radio\" type=\"radio\" name=\"flexRadioDefault\" id=\"flexRadioDefault2\">\r\n          </div>\r\n          <div class=\"right-side\">\r\n            <div class=\"scheme-name\">\r\n              <div class=\"scheme-title\">Individual Investment Scheme</div>\r\n              <div class=\"scheme-monthly\">₹8000/M</div>\r\n            </div>\r\n            <div class=\"scheme-details\">\r\n              <span class=\"scheme-id\">GPP Id: {{scheme.GPPId}}</span>\r\n              <!-- <span class=\"scheme-maturity\">Maturity Date: 12 April 2024</span> -->\r\n            </div>\r\n            <div class=\"scheme-amount\">₹{{scheme.amount}}</div>\r\n          </div>\r\n        </div>\r\n      </label>\r\n    </div>\r\n    <div class=\"reedem_error d-flex justify-content-center align-items-center\" *ngIf=\"showReedemError\">\r\n      Please add more ₹{{vaildAmount}} to reedem this scheme\r\n    </div>\r\n  </div>\r\n</ng-template>"]}