simpo-component-library 2.0.17 → 2.0.19

package/fesm2022/simpo-component-library.mjs

@@ -3603,11 +3603,12 @@ var cartType;
 })(cartType || (cartType = {}));
 
 class StorageServiceService {
-    constructor(eventService, cookieService, restService, router) {
+    constructor(eventService, cookieService, restService, router, messageService) {
         this.eventService = eventService;
         this.cookieService = cookieService;
         this.restService = restService;
         this.router = router;
+        this.messageService = messageService;
         this.totalCartItems = 0;
         this.databaseName = "USER";
         this.databaseVersion = 1;
@@ -3696,11 +3697,6 @@ class StorageServiceService {
         if (this.router.url.includes('cart'))
             return;
         const userDetails = this.getUser();
-        this.getCartProduct(userDetails?.userId).then((products) => {
-            console.log("Merged products:", products);
-        }).catch((error) => {
-            console.error("Error:", error);
-        });
         if (!!userDetails) {
             this.eventService.showLoadingScreen.emit(true);
             const request = forkJoin([
@@ -3760,15 +3756,17 @@ class StorageServiceService {
         const transaction = this.database.transaction(this.cartCollectionName, "readwrite");
         return await transaction.objectStore(this.cartCollectionName).getAll();
     }
-    async getCartProduct(userId) {
+    async getCartProduct() {
         try {
             const cartResponse = await this.getUserCart();
             return new Promise((resolve, reject) => {
                 cartResponse.onsuccess = async (cartData) => {
                     const indexDBProduct = cartData.target.result;
-                    if (userId) {
+                    const userDetails = this.getUser();
+                    if (userDetails?.userId) {
                         try {
-                            const response = await this.restService.getUserItems(userId, "CART").toPromise();
+                            const response = await this.restService.getUserItems(userDetails?.userId, "CART").toPromise();
+                            localStorage.setItem('cartId', response.data?.[0]?.cartId);
                             const serverDBProduct = response?.data?.[0]?.orderedItems ?? [];
                             for (let localProduct of indexDBProduct) {
                                 let productFound = false;
@@ -3881,7 +3879,7 @@ class StorageServiceService {
     storePaymentFor(paymentFor) {
         this.cookieService.set("paymentFor", paymentFor, 7);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: StorageServiceService, deps: [{ token: EventsService }, { token: i2$2.CookieService }, { token: RestService }, { token: i2$3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: StorageServiceService, deps: [{ token: EventsService }, { token: i2$2.CookieService }, { token: RestService }, { token: i2$3.Router }, { token: i5$1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: StorageServiceService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: StorageServiceService, decorators: [{
@@ -3889,7 +3887,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: EventsService }, { type: i2$2.CookieService }, { type: RestService }, { type: i2$3.Router }] });
+        }], ctorParameters: () => [{ type: EventsService }, { type: i2$2.CookieService }, { type: RestService }, { type: i2$3.Router }, { type: i5$1.MessageService }] });
 
 class UserBasicInfoComponent {
     constructor(restService, router, dialogRef, storageService, messageService) {
@@ -4591,9 +4589,10 @@ class OrderedItems {
 }
 
 class CartService {
-    constructor(storageService, restService) {
+    constructor(storageService, restService, messageService) {
         this.storageService = storageService;
         this.restService = restService;
+        this.messageService = messageService;
     }
     addItemFromCartPage(product, userCart) {
         if (product.quantity) {
@@ -4669,6 +4668,65 @@ class CartService {
     clearCartItems() {
         this.storageService.clearUserCart();
     }
+    addItemToLocalCart(product, type) {
+        if (this.isItemOutOfStock(product)) {
+            this.messageService.add({ severity: 'warn', summary: 'Cart', detail: 'Item is not available as of now. We will notify you once available' });
+            return;
+        }
+        if (!product?.quantity)
+            product.quantity = 0;
+        if (type == 'ADD') {
+            product.quantity += 1;
+        }
+        else {
+            product.quantity -= 1;
+        }
+        this.storageService.getUserCart().then((cartResponse) => {
+            cartResponse.onsuccess = (cartData) => {
+                const userCart = cartData.target.result ?? [];
+                let orderedItem = new OrderedItems();
+                if (product?.itemVariant?.length) {
+                    const itemVarient = this.getItemVarient(product, product.varientId);
+                    if (itemVarient) {
+                        itemVarient.quantity = product.quantity;
+                        orderedItem = this.objectMapper(product, itemVarient.variantId);
+                    }
+                }
+                else {
+                    orderedItem = this.objectMapper(product);
+                }
+                let productFound = false;
+                for (let localProduct of userCart) {
+                    if (localProduct.varientId === product.varientId) {
+                        localProduct.quantity = type === 'ADD' ? localProduct.quantity + 1 : localProduct.quantity - 1;
+                        if (localProduct.quantity == 0) {
+                            this.removeItemFromCart(localProduct);
+                        }
+                        else {
+                            this.storageService.addProductToCart(localProduct);
+                        }
+                        productFound = true;
+                        break;
+                    }
+                }
+                if (!productFound) {
+                    orderedItem.quantity = type === 'ADD' ? 1 : -1;
+                    this.storageService.addProductToCart(orderedItem);
+                }
+            };
+        });
+    }
+    isItemOutOfStock(product) {
+        return product.itemInventory?.openingStock == 0;
+    }
+    getItemVarient(product, varientId) {
+        let selectedVarient = null;
+        product?.itemVariant?.forEach((varient) => {
+            if (varient.variantId == varientId)
+                selectedVarient = varient;
+        });
+        return selectedVarient;
+    }
     storeDataToServer() {
         // const userCart = UserCart as never as Cart;
         // const userWishlist = UserFavourites as never as Cart;
@@ -4681,7 +4739,7 @@ class CartService {
         //   this.restService.addItemToDB(UserFavourites)
         // ]);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: CartService, deps: [{ token: StorageServiceService }, { token: RestService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: CartService, deps: [{ token: StorageServiceService }, { token: RestService }, { token: i5$1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: CartService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImport: i0, type: CartService, decorators: [{
@@ -4689,7 +4747,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.4", ngImpor
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: () => [{ type: StorageServiceService }, { type: RestService }] });
+        }], ctorParameters: () => [{ type: StorageServiceService }, { type: RestService }, { type: i5$1.MessageService }] });
 
 class CartComponent extends BaseSection {
     constructor(_eventService, cartService, router, restService, matDialog, storageService, messageService, bottomSheet, matDialogData, dialogRef) {
@@ -4713,6 +4771,7 @@ class CartComponent extends BaseSection {
         this.enteredCouponCode = "";
         this.couponList = [];
         this.cartInfo = {
+            cartId: localStorage.getItem("cartId"),
             orderedItems: null,
             businessId: localStorage.getItem("bId") ?? localStorage.getItem("businessId"),
             billdetails: {
@@ -4744,7 +4803,7 @@ class CartComponent extends BaseSection {
                 // this.getIndexDBData();
             }
         });
-        this.getIndexDBData();
+        this.updateUserCartV2();
         // if (this.storageService.getUser()) {
         //   this.updateUserCart();
         // } else {
@@ -4840,6 +4899,49 @@ class CartComponent extends BaseSection {
             }
         });
     }
+    updateUserCartV2() {
+        this.storageService.getCartProduct().then((products) => {
+            const deliveryOption = JSON.parse(localStorage.getItem("deliveryOptions") ?? "{}");
+            this.cartInfo.orderedItems = products;
+            if (!this.cartInfo?.cartId && !(localStorage.getItem("cartId") == "undefined" || localStorage.getItem("cartId") == "null")) {
+                this.cartInfo['cartId'] = localStorage.getItem("cartId");
+            }
+            this.userDetails = this.storageService.getUser();
+            if (this.userDetails) {
+                this.getCouponList();
+                this.cartInfo.userDetails = {
+                    "userId": this.userDetails?.userId,
+                    "userName": this.userDetails?.contact.name,
+                    "mobile": this.userDetails?.contact.mobile,
+                    "email": this.userDetails?.contact.email,
+                };
+                if (!(localStorage.getItem("couponId") == "undefined" || localStorage.getItem("couponId") == "null"))
+                    this.cartInfo.billdetails.couponId = localStorage.getItem("couponId");
+                if (!(localStorage.getItem("couponCode") == "undefined" || localStorage.getItem("couponCode") == "null"))
+                    this.cartInfo.billdetails.couponCode = localStorage.getItem("couponCode");
+                const restResponse = this.restService.addItemToDB(this.cartInfo).toPromise();
+                restResponse.then((cartResponse) => {
+                    this.cartInfo = cartResponse.data;
+                    this.storageService.clearUserCart();
+                });
+            }
+            else {
+                this.cartInfo.billdetails.totalGrossValue = 0;
+                this.cartInfo.billdetails.totalTax = 0;
+                this.cartInfo.billdetails.deliveryCharges = 0;
+                this.cartInfo.billdetails.totalNetValue = 0;
+                this.cartInfo.totalAmount = 0;
+                products.forEach((item) => {
+                    this.cartInfo.billdetails.totalGrossValue += (item.discountedPrice * (item.quantity ?? 1));
+                    this.cartInfo.billdetails.totalTax += (item.quantity * (item.itemTax ?? 0));
+                });
+                this.cartInfo.billdetails.deliveryCharges = (deliveryOption?.minOrderAmount > this.cartInfo.billdetails.totalGrossValue) ? 0 : (deliveryOption?.deliveryCharges ?? 0);
+                this.cartInfo.billdetails.totalNetValue = this.cartInfo.billdetails.totalGrossValue - this.cartInfo.billdetails.deliveryCharges;
+                this.cartInfo.totalAmount = this.cartInfo.billdetails.totalNetValue + this.getTaxAmount();
+                +this.cartInfo.billdetails.deliveryCharges;
+            }
+        });
+    }
     // updateUserCart2() {
     //   const deliveryOption = JSON.parse(localStorage.getItem("deliveryOptions") ?? "{}");
     //   this.userDetails = this.storageService.getUser() as User;
@@ -5351,7 +5453,7 @@ class NavbarSectionComponent {
         this.showEditors = false;
         this.showSearchBar = false;
         this.getScreenSize();
-        this.storageService.updateAllData();
+        // this.storageService.updateAllData();
     }
     searchProducts() {
         this.router.navigate(['/list'], { queryParams: { searchTxt: this.searchText } });
@@ -7677,29 +7779,50 @@ class FeaturedProductsComponent extends BaseSection {
         this.apiLoading = true;
         this.restService.getFeaturedProduct(this.content?.collectionId).subscribe((response) => {
             this.responseData = response;
-            this.storageService.getUserCart().then((cartResponse) => {
-                cartResponse.onsuccess = (cartData) => {
-                    this.apiLoading = false;
-                    this.USER_CART = cartData.target.result;
-                    this.responseData?.forEach((product) => {
-                        this.USER_CART?.forEach((item) => {
-                            if (item.itemId == product.itemId) {
-                                if (product?.itemVariant?.length > 0) {
-                                    const itemVarient = product?.itemVariant?.[0];
-                                    if (itemVarient.variantId == item.varientId) {
-                                        product.itemImages = itemVarient.variantImages ?? [];
-                                        product.price = itemVarient.itemVariantPrice;
-                                        product.quantity = item.quantity;
-                                    }
-                                }
-                                else {
+            // this.storageService.getUserCart().then((cartResponse) => {
+            //   cartResponse.onsuccess = (cartData: any) => {
+            //     this.apiLoading = false;
+            //     this.USER_CART = cartData.target.result as unknown as OrderedItems[];
+            //     this.responseData?.forEach((product: Product) => {
+            //       this.USER_CART?.forEach((item: OrderedItems) => {
+            //         if (item.itemId == product.itemId) {
+            //           if (product?.itemVariant?.length > 0) {
+            //             const itemVarient: ItemVariant = product?.itemVariant?.[0];
+            //             if (itemVarient.variantId == item.varientId) {
+            //               product.itemImages = itemVarient.variantImages ?? [];
+            //               product.price = itemVarient.itemVariantPrice;
+            //               product.quantity = item.quantity;
+            //             }
+            //           } else {
+            //             product.quantity = item.quantity;
+            //           }
+            //         }
+            //       })
+            //     })
+            //   }
+            // },(err) => {
+            //   this.apiLoading = false;
+            // })
+            this.storageService.getCartProduct().then((products) => {
+                this.apiLoading = false;
+                this.responseData?.forEach((product) => {
+                    products?.forEach((item) => {
+                        if (item.itemId == product.itemId) {
+                            if (product?.itemVariant?.length > 0) {
+                                const itemVarient = product?.itemVariant?.[0];
+                                if (itemVarient.variantId == item.varientId) {
+                                    product.itemImages = itemVarient.variantImages ?? [];
+                                    product.price = itemVarient.itemVariantPrice;
                                     product.quantity = item.quantity;
                                 }
                             }
-                        });
+                            else {
+                                product.quantity = item.quantity;
+                            }
+                        }
                     });
-                };
-            }, (err) => {
+                });
+            }).catch(err => {
                 this.apiLoading = false;
             });
             this.storageService.getUserWhishlist().then((wishlistResponse) => {
@@ -7727,43 +7850,44 @@ class FeaturedProductsComponent extends BaseSection {
         });
     }
     addItemToCart(product, type) {
-        if (this.isItemOutOfStock(product)) {
-            this.messageService.add({ severity: 'warn', summary: 'Cart', detail: 'Item is not available as of now. We will notify you once available' });
-            return;
-        }
-        if (!product?.quantity)
-            product.quantity = 0;
-        if (type == 'ADD') {
-            product.quantity += 1;
-        }
-        else {
-            product.quantity -= 1;
-        }
-        if (product?.itemVariant?.length) {
-            const itemVarient = this.getItemVarient(product, product.varientId);
-            if (itemVarient) {
-                itemVarient.quantity = product.quantity;
-                this.cartService.addItemToCart(product, itemVarient.variantId);
-            }
-        }
-        else {
-            this.cartService.addItemToCart(product);
-        }
-        if (product.quantity) {
-            let isPresent = false;
-            this.USER_CART?.forEach((item) => {
-                if (item.varientId == product.varientId) {
-                    item.quantity = product.quantity;
-                    isPresent = true;
-                }
-            });
-            if (!isPresent)
-                this.USER_CART?.push(new OrderedItems(product, product.varientId));
-        }
-        else {
-            this.USER_CART = this.USER_CART?.filter((item) => item.varientId != product.varientId) ?? [];
-        }
+        this.cartService.addItemToLocalCart(product, type);
     }
+    // addItemToCart(product: Product, type: 'ADD' | 'SUBSTRACT') {
+    //   if (this.isItemOutOfStock(product)) {
+    //     this.messageService.add({ severity: 'warn', summary: 'Cart', detail: 'Item is not available as of now. We will notify you once available' });
+    //     return;
+    //   }
+    //   if (!product?.quantity)
+    //     product.quantity = 0;
+    //   if (type == 'ADD') {
+    //     product.quantity += 1;
+    //   }
+    //   else {
+    //     product.quantity -= 1;
+    //   }
+    //   if (product?.itemVariant?.length) {
+    //     const itemVarient: ItemVariant | null = this.getItemVarient(product, product.varientId);
+    //     if (itemVarient) {
+    //       itemVarient.quantity = product.quantity;
+    //       this.cartService.addItemToCart(product, itemVarient.variantId);
+    //     }
+    //   } else {
+    //     this.cartService.addItemToCart(product);
+    //   }
+    //   if (product.quantity) {
+    //     let isPresent: boolean = false;
+    //     this.USER_CART?.forEach((item: OrderedItems) => {
+    //       if (item.varientId == product.varientId) {
+    //         item.quantity = product.quantity;
+    //         isPresent = true;
+    //       }
+    //     })
+    //     if (!isPresent)
+    //       this.USER_CART?.push(new OrderedItems(product, product.varientId));
+    //   } else {
+    //     this.USER_CART = this.USER_CART?.filter((item: OrderedItems) => item.varientId != product.varientId) ?? [];
+    //   }
+    // }
     toggleItemToFav(event, product, type) {
         if (type == 'ADD') {
             product.whislist = true;