ng-easycommerce-v18 0.0.1 → 0.0.3

package/esm2022/lib/ec-services/blocks.service.mjs

@@ -0,0 +1,52 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ApiConstantsService } from '../constants';
+import { BlocksRepositoryService } from './blocks-repository.service';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de tipo adapter para manejar los bloques.
+ * @class BlocksService
+ */
+export class BlocksService {
+    /**
+     * Constantes de la API
+     */
+    apiConstants = inject(ApiConstantsService);
+    /**
+     * Servicio de BlocksRepository.
+     */
+    blocksRepositoryService = inject(BlocksRepositoryService);
+    /**
+     * Subject para manejar los bloques recibidos.
+     */
+    blocksSubject = new BehaviorSubject([]);
+    /**
+     * Observable de bloques.
+     */
+    blocks$ = this.blocksSubject.asObservable();
+    //API URLS
+    /**
+     * Devuelve la url para interactuar con el bloque de contacto.
+     * @returns
+     */
+    contactFormResponseAPI() { return `${this.apiConstants.CMS_URL}${this.apiConstants.LOCALE}/contact-form/response`; }
+    //METHODS
+    /**
+     * Obtiene los bloques de una sección en especifico.
+     * @param section
+     * @returns Observable de los bloques.
+     */
+    getBlocks(section) {
+        return this.blocksRepositoryService.getBlocks(section);
+    }
+    constructor() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ec-services/cart.service.mjs

@@ -0,0 +1,465 @@
+import { inject, Injectable } from '@angular/core';
+import { AuthService } from './auth.service';
+import { ToastService } from './toast.service';
+import { ConnectionService } from '../api';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { BehaviorSubject, combineLatest, firstValueFrom, map } from 'rxjs';
+import { AnalyticsService } from './analytics';
+import { LocalStorageService } from './local-storage.service';
+import { ChannelService } from './channel.service';
+import { NgxLocalStorageService } from './ngx-local-storage.service';
+import * as i0 from "@angular/core";
+export class CartService {
+    _authService = inject(AuthService);
+    _toastService = inject(ToastService);
+    _connection = inject(ConnectionService);
+    _apiConsts = inject(ApiConstantsService);
+    _analyticsService = inject(AnalyticsService);
+    _localStorage = inject(LocalStorageService);
+    _channelService = inject(ChannelService);
+    _consts = inject(CoreConstantsService);
+    _storage = inject(NgxLocalStorageService);
+    _cartSubject = new BehaviorSubject(null);
+    _promotionsSubject = new BehaviorSubject([]);
+    _couponSubject = new BehaviorSubject(null);
+    _cartItemsSubject = new BehaviorSubject([]);
+    _requestInProcess = new BehaviorSubject(false);
+    _balanceCustomerSubject = new BehaviorSubject({
+        allowAnyPaymentMethod: false,
+        allowExceedBalance: false,
+        creditAmount: 0,
+        showMax: false,
+        showPrice: false,
+        remainingCredits: 0,
+    });
+    CART_KEY = 'cart';
+    CART_TOKEN_KEY = 'cart_token';
+    _items = [];
+    _count = 0;
+    cartToken = '';
+    channelConfig = {};
+    _locale = "";
+    cartItems$ = this._cartItemsSubject.asObservable().pipe(map(items => this.switchPriceInCartItem(items)));
+    coupon$ = this._couponSubject.asObservable();
+    cart$ = this._cartSubject.asObservable();
+    loading$ = this._requestInProcess.asObservable();
+    _haveToUpdate = true;
+    //API URL
+    _cartBaseUrl = `${this._apiConsts.SHOP_API_URL}${this._apiConsts.CHANNEL}/carts`;
+    updateItemQuantityApi(item_id) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }
+    addItemApi() { return this._cartBaseUrl + '/' + this.cartToken + '/items?locale=' + this._apiConsts.LOCALE; }
+    cartItemsApi() { return this._cartBaseUrl + '?locale=' + this._apiConsts.LOCALE; }
+    deleteItemApi(item_id) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }
+    couponApi() { return this._cartBaseUrl + '/' + this.cartToken + '/coupon'; }
+    ;
+    constructor() {
+        this._requestInProcess.next(true);
+        this.cartToken = this._localStorage.getItem(this.CART_TOKEN_KEY) || null;
+        this.initializeDataCart();
+        this._channelService.channel$.subscribe(res => this.channelConfig = res);
+    }
+    /**
+     * Inicializa el carrito con los datos del local storage en caso de que existan o no.
+     */
+    initializeDataCart() {
+        combineLatest([this._authService.loggedIn$, this._storage.getItem(this.CART_KEY)]).subscribe({
+            next: ([loggedIn, token]) => {
+                //console.log(loggedIn, token);
+                this._items = token || [];
+                this.getCart();
+            }
+        });
+    }
+    /**
+     * Obtiene el carrito desde el backend y lo inicializa.
+     * Si existe el cartToken y hay items en el carrito, envía el token como parámetro.
+     */
+    getCart() {
+        //console.warn(this._items, this._items.length, this.cartToken)
+        firstValueFrom(this._connection.post(this.cartItemsApi(), ((this.cartToken && this._items.length >= 1) && { token: this.cartToken }))).then((res) => {
+            //console.log(res)	
+            this.initializeCart(res);
+        });
+    }
+    /**
+     * Configura el carrito con los parametros iniciales.
+     * @param response
+     * @returns
+     */
+    initializeCart(response) {
+        this.cartToken = response.tokenValue;
+        this._localStorage.setItem(this.CART_TOKEN_KEY, this.cartToken);
+        this._locale = response.locale;
+        this.updateCartObj(response, false);
+        this.updateCartItems(this.transformItems(response.items));
+        this._requestInProcess.next(false);
+        return true;
+    }
+    /**
+     * Actualiza los items del carrito.
+     * @param items
+     */
+    updateCartItems(items) {
+        this._items = items;
+        this._count = items.length;
+        this._cartItemsSubject.next(this._items);
+        this.updateLocalCart();
+        this._requestInProcess.next(false);
+    }
+    /**
+     * Agrega un producto al carrito con la cantidad deseada.
+     * @param product Producto a agregar
+     * @param quantity Cantidad
+     * @param variantId Id de la variante
+     * @returns
+     */
+    addToCart(product, quantity, variantId) {
+        //console.log(product);
+        if (!this._authService.isAbleToBuy()) {
+            this._toastService.show('must-select-customer');
+            return;
+        }
+        this._requestInProcess.next(true);
+        let added = this.addIfAllreadyExists(product, variantId, quantity);
+        if (!added) {
+            firstValueFrom(this._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variantId }))
+                .then(res => {
+                // Manejar la respuesta HTTP exitosa (código 200)
+                this.appendToCart(res);
+                this._toastService.show('product-added');
+            }, err => {
+                // Manejar el error de la llamada HTTP (código 500 u otro error)
+                if (err.status === 500) {
+                    // Código de error 500 (timeout)
+                    this.handleError(err);
+                    this._toastService.show('cart-error');
+                }
+                else {
+                    // Otro código de error
+                    this.handleError(err);
+                    this._toastService.show('error-server');
+                }
+            });
+        }
+    }
+    /**
+     * Actualiza el carrito agregando los nuevos items.
+     * @param cart
+     */
+    appendToCart(cart) {
+        this.updateCartObj(cart);
+        this._items = this.transformItems(cart.items);
+        this._count = this._items.length;
+        this._requestInProcess.next(false);
+        this.updateLocalCart();
+        this._cartItemsSubject.next(this._items);
+    }
+    /**
+     * Mapea los items del carrito para darle un mejor formato similar a la interfaz `CartItem`.
+     * @param items
+     * @returns
+     */
+    transformItems(items) {
+        return items.map((item) => {
+            return {
+                product: item.product,
+                variant_id: item.product.variants[0].code,
+                lot: item.orderItemLot,
+                quantity: item.quantity,
+                item_id: item.id,
+                total: item.total
+            };
+        });
+    }
+    /**
+     * Chequea si el producto ya existe en el carrito de compras.
+     * @param product
+     * @param variantId
+     * @param quantityAdd Cantidad a agregar. Por defecto es 1.
+     */
+    addIfAllreadyExists(product, variantId, quantityAdd = 1) {
+        return this._items.find((item, index) => {
+            if (item.product.id == product.id && item.variant_id == variantId) {
+                this.updateItemQuantity(item, this.findItem(product.id).quantity + quantityAdd);
+                return true;
+            }
+            return false;
+        });
+    }
+    /**
+     * Obtiene la cantidad de un producto del item del carrito
+     * @param codeVariant codigo de la variante.
+     * @returns la cantidad o `0` en su defecto.
+     */
+    getCountFromItemInCart(codeVariant) {
+        return this._items.find(item => item.variant_id == codeVariant)?.quantity || 0;
+    }
+    /**
+     * Obtiene un observable con la cantidad de items en el carrito.
+     */
+    getCountCartItems() {
+        return this.cartItems$.pipe(map((cartItems) => cartItems?.length));
+    }
+    /**
+     * Mapea los productos en el carrito para cambiar el precio obteniendo de la variante y seleccionando si es
+     * precio de oferta o el precio normal.
+     * @param items
+     * @returns
+     */
+    switchPriceInCartItem = (items) => {
+        return items.map(item => {
+            if (item.product) {
+                item.product.price = item.product.variants[0].saleprice ? item.product.variants[0].saleprice : item.product.variants[0].price;
+            }
+            return item;
+        });
+    };
+    /**
+     * Actualiza la cantidad de un producto existente en el carrito.
+     * @param item el item a actualizar.
+     * @param quantity la cantidad nueva.
+     */
+    updateItemQuantity(item, quantity) {
+        if (this.validateQuantity(item, quantity)) {
+            firstValueFrom(this._connection.put(this.updateItemQuantityApi(this.findItemByIdVariant(item.variant_id)), { 'quantity': Number(quantity) })).then(res => this.updateCartObj(res) && this.updateCartItemQuantity(item.variant_id, Number(quantity)), err => this.handleError(err));
+        }
+    }
+    /**
+     * Maneja el error en caso de que no se pueda agregar al carrito el producto.
+     * @param err
+     */
+    handleError(err) {
+        this._toastService.show('operation-error-param');
+        this._requestInProcess.next(false);
+    }
+    /**
+     * Actualiza la cantidad del item del producto del carrito.
+     * @param variantId ID de la variante para buscar el item.
+     * @param quantity Nueva cantidad.
+     */
+    updateCartItemQuantity(variantId, quantity) {
+        //console.log("updateCartItemQuantity", this._items, variantId)
+        let newQuantity = this._items.find(item => item.variant_id == variantId).quantity = quantity;
+        this._cartItemsSubject.next(this._items);
+        this._requestInProcess.next(false);
+        this.updateLocalCart();
+        this._toastService.show('product-updated', { quantity: newQuantity });
+    }
+    /**
+     * Actualiza los datos del carrito en el localStorage.
+     */
+    updateLocalCart() {
+        this._storage.setItem(this.CART_KEY, this._items);
+    }
+    /**
+     * Actualiza el carrito. Emite evento de analitics.
+     * Actualiza todo lo relacionado al cupón.
+     * @param cart Respuesta producida por el enpoint con información del carrito.
+     * @param emitEvent
+     * @returns
+     */
+    updateCartObj(cart, emitEvent = true) {
+        this._cartSubject.next(cart);
+        emitEvent && this._analyticsService.callEvent('add_to_cart', cart);
+        //this._promotionsSubject.next(this.orderUtils.getPromotions(cart, true));
+        cart.couponCode
+            ? this.formatCoupon(cart)
+            : this._couponSubject.next(null);
+        return true;
+    }
+    /**
+     * Aplicar un mejor formato a los datos de los cupones aplicados.
+     * @param cart
+     */
+    formatCoupon(cart) {
+        let current_coupon = this._couponSubject.value;
+        let coupon = { code: cart.couponCode };
+        try {
+            const key = Object.keys(cart.cartDiscounts)[0];
+            coupon = {
+                ...coupon,
+                amount: (cart.cartDiscounts && cart.cartDiscounts[key].amount.current) || 0,
+                name: (cart.cartDiscounts && cart.cartDiscounts[key].name) || 'no-name'
+            };
+        }
+        catch (e) { }
+        (coupon != current_coupon) && this._couponSubject.next(coupon);
+        //console.log(coupon);
+    }
+    /**
+     * Retorna el ID del item del carrito.
+     * @param variant_id Id de la variante utilizada para buscar el item.
+     * @returns
+     */
+    findItemByIdVariant(variant_id) {
+        return this._items.find(item => item.variant_id == variant_id).item_id;
+    }
+    /**
+     * Valida la cantidad para saber si se puede actualizar o no.
+     * @param item item del carrito
+     * @param quantity cantidad a agregar
+     * @returns
+     */
+    validateQuantity(item, quantity) {
+        if ((this.getCountFromItemInCart(item.productCode) + quantity) > item.product.variants[0].maximumItemsQuantity) {
+            this._toastService.show('maximum-items-quantity', { quantity: item.product.variants[0].maximumItemsQuantity });
+            return false;
+        }
+        if ((this.getCountFromItemInCart(item.productCode) + quantity) < item.product.variants[0].minimumItemsQuantity) {
+            this._toastService.show('minimum-items-quantity', { quantity: item.product.variants[0].minimumItemsQuantity });
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Busca un producto a través de su ID en los items del carrito.
+     * @param product_id
+     * @returns
+     */
+    findItem(product_id) { return this._items.find((item) => item.product.id == product_id); }
+    /**
+     * Elimina un item del carrito en el backend.
+     * @param item item a eliminar
+     * @param toast indica si se dispara un toast  o no. Por defecto en `true`.
+     */
+    deleteCartItem(item, toast = true) {
+        let idItemSearched = this.findItemByIdVariant(item.variant_id);
+        //console.log(idItemSearched)
+        this._requestInProcess.next(true);
+        firstValueFrom(this._connection.delete(this.deleteItemApi(idItemSearched))).then(res => {
+            this.removeCartItem(res, item, toast);
+            this._requestInProcess.next(false);
+        }, err => {
+            this.handleError(err);
+            this._requestInProcess.next(false);
+        });
+    }
+    /**
+     * Elimina un item en carrito de forma local.
+     * @param cart Carrito, es decir, respuesta del backend.
+     * @param product producto a eliminar
+     * @param toast {boolean} para indicar si se dispara un toast o no.
+     */
+    removeCartItem(cart, product, toast) {
+        this.updateCartObj(cart, false);
+        this._items.splice(this._items.findIndex(value => value.item_id === product.item_id), 1);
+        this._cartItemsSubject.next(this._items);
+        toast && this._requestInProcess.next(false);
+        toast && this._toastService.show('product-removed');
+        this.updateLocalCart();
+        this._analyticsService.callEvent('remove_from_cart', { ...product, currency: this._consts.currency.code });
+    }
+    /**
+     * Agrega un cupon al carrito.
+     * @param value Codigo del cupón.
+     */
+    addCoupon(value) {
+        firstValueFrom(this._connection.put(this.couponApi(), { coupon: value })).then(res => {
+            //console.log(res)
+            this.updateCartObj(res);
+            this._toastService.show('Cupon aplicado');
+        }, err => {
+            //console.error(err) 
+            this._toastService.show('invalid-coupon');
+        });
+    }
+    /**
+     * Elimina un cupón del carrito.
+     */
+    removeCoupon() {
+        firstValueFrom(this._connection.delete(this.couponApi())).then(res => {
+            //console.log(res)
+            this.updateCartObj(res);
+        });
+    }
+    /**
+     * Retorna un observable con el subtotal del carrito.
+     * @returns
+     */
+    getSubTotalAmount() {
+        return this.cart$.pipe(map((cart) => cart?.totals?.items));
+    }
+    /**
+     * Retorna un observable con el total del monto de las promociones aplicadas.
+     * @returns
+     */
+    getTotalPromotionAmount() {
+        return this.cart$.pipe(map((cart) => cart?.totals?.promotion));
+    }
+    /**
+     * Retorna un observable con el monto de los impuestos aplicados.
+     * @returns
+     */
+    getTaxesAmount() {
+        return this.cart$.pipe(map((cart) => cart?.totals?.taxes > 0 ? cart?.totals?.taxes : 0));
+    }
+    /**
+     * Retorna un observable con el monto total del carrito.
+     * @returns
+     */
+    getTotalAmount() {
+        return this.cart$.pipe(map((cart) => cart?.totals?.total));
+    }
+    /**
+     * Retorna el token del carrito.
+     * @returns
+     */
+    getCartToken() {
+        return this.cartToken;
+    }
+    changeHaveToUpdate = (value) => this._haveToUpdate = value;
+    clearAndResetCustomerCart() {
+        console.log("Clearing and reseting...");
+        this.resetCart(this.getCartByCustomer);
+    }
+    getCartByCustomer = async () => this._connection.post(this.cartItemsApi()).subscribe(res => this.initializeCart(res));
+    resetCart = (fn) => {
+        this._items = [];
+        this._cartSubject.next(null);
+        this.updateBalanceAttributes(null);
+        this.cartToken = null;
+        this._cartItemsSubject.next([]);
+        this._count = 0;
+        this._localStorage.setItem(this.CART_KEY, "[]");
+        this._localStorage.removeItem(this.CART_TOKEN_KEY);
+        fn && fn();
+    };
+    clearAndResetCart() {
+        this.resetCart(() => this.getCart);
+    }
+    updateBalanceAttributes(cartData) {
+        const balanceData = {
+            allowAnyPaymentMethod: cartData?.allowAnyPaymentMethod ?? false,
+            allowExceedBalance: cartData?.allowExceedBalance ?? false,
+            creditAmount: cartData?.creditAmount ?? null,
+            showMax: cartData?.showMax ?? false,
+            showPrice: cartData?.showPrice ?? false,
+            remainingCredits: cartData?.creditAmount && cartData?.creditAmount >= cartData?.totals.total
+                ? cartData?.creditAmount - cartData?.totals.total
+                : 0,
+        };
+        this._balanceCustomerSubject.next(balanceData);
+        console.log(balanceData);
+    }
+    addToLot(product, quantity, variant_id, id, order_item_id, lot_quantity, unit_price, unit_total, ajustement_total, total_lot, lot_status, date_request, notes, shipping_address_id, shipping_address_name, action) {
+        if (!this._authService.isAbleToBuy()) {
+            this._toastService.show('must-select-customer');
+            return;
+        }
+        let added = '';
+        !added && this._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variant_id, id: id || '', order_item_id: order_item_id || '', lot_quantity: lot_quantity || '', unit_price: unit_price || '', unit_total: unit_total || '', ajustement_total: ajustement_total || '', total_lot: total_lot || '', lot_status: lot_status || '', date_request: date_request || '', notes: notes || '', shipping_address_id: shipping_address_id || '', shipping_address_name: shipping_address_name || '', action: action || 'newlot' })
+            .subscribe({
+            next: (res) => this.appendToCart(res),
+            error: (err) => this.handleError(err)
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CartService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CartService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cart.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/cart.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { BalanceCustomer, CartItem, ICoupon, Product } from '../interfaces';\r\nimport { AuthService } from './auth.service';\r\nimport { ToastService } from './toast.service';\r\nimport { ConnectionService } from '../api';\r\nimport { ApiConstantsService, CoreConstantsService } from '../constants';\r\nimport { BehaviorSubject, combineLatest, firstValueFrom, map, Observable } from 'rxjs';\r\nimport { AnalyticsService } from './analytics';\r\nimport { LocalStorageService } from './local-storage.service';\r\nimport { ChannelService } from './channel.service';\r\nimport { NgxLocalStorageService } from './ngx-local-storage.service';\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class CartService {\r\n\tprivate _authService: AuthService = inject(AuthService);\r\n\tprivate _toastService: ToastService = inject(ToastService);\r\n\tprivate _connection: ConnectionService = inject(ConnectionService);\r\n\tprivate _apiConsts: ApiConstantsService = inject(ApiConstantsService);\r\n\tprivate _analyticsService: AnalyticsService = inject(AnalyticsService);\r\n\tprivate _localStorage: LocalStorageService = inject(LocalStorageService);\r\n\tprivate _channelService: ChannelService = inject(ChannelService);\r\n\tprivate _consts: CoreConstantsService = inject(CoreConstantsService);\r\n\tprivate _storage: NgxLocalStorageService = inject(NgxLocalStorageService);\r\n\r\n\tprivate _cartSubject: BehaviorSubject<any> = new BehaviorSubject(null);\r\n\tprivate _promotionsSubject: BehaviorSubject<any> = new BehaviorSubject([]);\r\n\tprivate _couponSubject: BehaviorSubject<any> = new BehaviorSubject(null);\r\n\tprivate _cartItemsSubject: BehaviorSubject<CartItem[]> = new BehaviorSubject<CartItem[]>([])\r\n\tprivate _requestInProcess: BehaviorSubject<boolean> = new BehaviorSubject(false);\r\n\tprivate _balanceCustomerSubject: BehaviorSubject<BalanceCustomer> = new BehaviorSubject<BalanceCustomer>({\r\n        allowAnyPaymentMethod: false,\r\n        allowExceedBalance: false,\r\n        creditAmount: 0,\r\n        showMax: false,\r\n        showPrice: false,\r\n        remainingCredits: 0,\r\n    });\r\n\r\n\tprivate readonly CART_KEY: string = 'cart';\r\n\tprivate readonly CART_TOKEN_KEY: string = 'cart_token';\r\n\r\n\tprivate _items: any[] = [];\r\n\tprivate _count: number = 0;\r\n\tpublic cartToken: string | null = '';\r\n\tpublic channelConfig: any = {};\r\n\tprivate _locale = \"\";\r\n\tpublic cartItems$ = this._cartItemsSubject.asObservable().pipe(map(items => this.switchPriceInCartItem(items)))\r\n\tpublic coupon$: Observable<any> = this._couponSubject.asObservable();\r\n\tpublic cart$: Observable<any> = this._cartSubject.asObservable();\r\n\tpublic loading$: Observable<boolean> = this._requestInProcess.asObservable();\r\n\tprivate _haveToUpdate = true;\r\n\r\n\t//API URL\r\n\tprivate _cartBaseUrl: string = `${this._apiConsts.SHOP_API_URL}${this._apiConsts.CHANNEL}/carts`;\r\n\r\n\tpublic updateItemQuantityApi(item_id: any) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }\r\n\tpublic addItemApi(): string { return this._cartBaseUrl + '/' + this.cartToken + '/items?locale=' + this._apiConsts.LOCALE }\r\n\tpublic cartItemsApi(): string { return this._cartBaseUrl + '?locale=' + this._apiConsts.LOCALE }\r\n\tpublic deleteItemApi(item_id: string) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }\r\n\tpublic couponApi() { return this._cartBaseUrl + '/' + this.cartToken + '/coupon' };\r\n\r\n\tconstructor() {\r\n\t\tthis._requestInProcess.next(true);\r\n\t\tthis.cartToken = this._localStorage.getItem(this.CART_TOKEN_KEY) || null;\r\n\t\tthis.initializeDataCart();\r\n\t\tthis._channelService.channel$.subscribe(res => this.channelConfig = res)\r\n\t}\r\n\t/**\r\n\t * Inicializa el carrito con los datos del local storage en caso de que existan o no.\r\n\t */\r\n\tprivate initializeDataCart() {\r\n\t\tcombineLatest([this._authService.loggedIn$, this._storage.getItem(this.CART_KEY)]).subscribe({\r\n\t\t\tnext: ([loggedIn, token]) => {\r\n\t\t\t\t//console.log(loggedIn, token);\r\n\t\t\t\tthis._items = token || [];\r\n\t\t\t\tthis.getCart()\r\n\t\t\t}\r\n\t\t})\r\n\t}\r\n\t/**\r\n\t * Obtiene el carrito desde el backend y lo inicializa. \r\n\t * Si existe el cartToken y hay items en el carrito, envía el token como parámetro.\r\n\t */\r\n\tprivate getCart() {\r\n\t\t//console.warn(this._items, this._items.length, this.cartToken)\r\n\t\tfirstValueFrom(\r\n\t\t\tthis._connection.post(this.cartItemsApi(), ((this.cartToken && this._items.length >= 1) && { token: this.cartToken }))\r\n\t\t).then((res: any) => {\r\n\t\t\t//console.log(res)\t\r\n\t\t\tthis.initializeCart(res)\r\n\t\t})\r\n\t}\r\n\t/**\r\n\t * Configura el carrito con los parametros iniciales.\r\n\t * @param response \r\n\t * @returns \r\n\t */\r\n\tinitializeCart(response: any): any {\r\n\t\tthis.cartToken = response.tokenValue;\r\n\t\tthis._localStorage.setItem(this.CART_TOKEN_KEY, this.cartToken);\r\n\t\tthis._locale = response.locale;\r\n\r\n\t\tthis.updateCartObj(response, false);\r\n\t\tthis.updateCartItems(this.transformItems(response.items));\r\n\t\tthis._requestInProcess.next(false);\r\n\t\treturn true;\r\n\t}\r\n\t/**\r\n\t * Actualiza los items del carrito.\r\n\t * @param items \r\n\t */\r\n\tupdateCartItems(items: any[]) {\r\n\t\tthis._items = items;\r\n\t\tthis._count = items.length;\r\n\t\tthis._cartItemsSubject.next(this._items);\r\n\t\tthis.updateLocalCart();\r\n\t\tthis._requestInProcess.next(false);\r\n\t}\r\n\t/**\r\n\t * Agrega un producto al carrito con la cantidad deseada. \r\n\t * @param product Producto a agregar\r\n\t * @param quantity Cantidad \r\n\t * @param variantId Id de la variante\r\n\t * @returns \r\n\t */\r\n\taddToCart(product: Product, quantity: number, variantId: string) {\r\n\t\t//console.log(product);\r\n\t\tif (!this._authService.isAbleToBuy()) {\r\n\t\t\tthis._toastService.show('must-select-customer')\r\n\t\t\treturn\r\n\t\t}\r\n\t\tthis._requestInProcess.next(true);\r\n\t\tlet added = this.addIfAllreadyExists(product, variantId, quantity);\r\n\r\n\t\tif (!added) {\r\n\t\t\tfirstValueFrom(\r\n\t\t\t\tthis._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variantId }))\r\n\t\t\t\t.then(\r\n\t\t\t\t\tres => {\r\n\t\t\t\t\t\t// Manejar la respuesta HTTP exitosa (código 200)\r\n\t\t\t\t\t\tthis.appendToCart(res);\r\n\t\t\t\t\t\tthis._toastService.show('product-added');\r\n\t\t\t\t\t},\r\n\t\t\t\t\terr => {\r\n\t\t\t\t\t\t// Manejar el error de la llamada HTTP (código 500 u otro error)\r\n\t\t\t\t\t\tif (err.status === 500) {\r\n\t\t\t\t\t\t\t// Código de error 500 (timeout)\r\n\t\t\t\t\t\t\tthis.handleError(err);\r\n\t\t\t\t\t\t\tthis._toastService.show('cart-error');\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t// Otro código de error\r\n\t\t\t\t\t\t\tthis.handleError(err);\r\n\t\t\t\t\t\t\tthis._toastService.show('error-server');\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Actualiza el carrito agregando los nuevos items.\r\n\t * @param cart \r\n\t */\r\n\tappendToCart(cart: any) {\r\n\t\tthis.updateCartObj(cart);\r\n\t\tthis._items = this.transformItems(cart.items);\r\n\t\tthis._count = this._items.length;\r\n\t\tthis._requestInProcess.next(false);\r\n\t\tthis.updateLocalCart();\r\n\t\tthis._cartItemsSubject.next(this._items);\r\n\t}\r\n\t/**\r\n\t * Mapea los items del carrito para darle un mejor formato similar a la interfaz `CartItem`.\r\n\t * @param items \r\n\t * @returns \r\n\t */\r\n\ttransformItems(items: any): any[] {\r\n\t\treturn items.map((item: any) => {\r\n\t\t\treturn {\r\n\t\t\t\tproduct: item.product,\r\n\t\t\t\tvariant_id: item.product.variants[0].code,\r\n\t\t\t\tlot: item.orderItemLot,\r\n\t\t\t\tquantity: item.quantity,\r\n\t\t\t\titem_id: item.id,\r\n\t\t\t\ttotal: item.total\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\t/**\r\n\t * Chequea si el producto ya existe en el carrito de compras.\r\n\t * @param product \r\n\t * @param variantId \r\n\t * @param quantityAdd Cantidad a agregar. Por defecto es 1.\r\n\t */\r\n\taddIfAllreadyExists(product: Product, variantId: string, quantityAdd: number = 1) {\r\n\t\treturn this._items.find((item: any, index) => {\r\n\t\t\tif (item.product.id == product.id && item.variant_id == variantId) {\r\n\t\t\t\tthis.updateItemQuantity(item, this.findItem(product.id).quantity + quantityAdd);\r\n\t\t\t\treturn true;\r\n\t\t\t}\r\n\t\t\treturn false;\r\n\t\t})\r\n\t}\r\n\t/**\r\n\t * Obtiene la cantidad de un producto del item del carrito \r\n\t * @param codeVariant codigo de la variante.\r\n\t * @returns la cantidad o `0` en su defecto.\r\n\t */\r\n\tgetCountFromItemInCart(codeVariant: any): number {\r\n\t\treturn this._items.find(item => item.variant_id == codeVariant)?.quantity || 0;\r\n\t}\r\n\t/**\r\n\t * Obtiene un observable con la cantidad de items en el carrito.\r\n\t */\r\n\tgetCountCartItems(): Observable<number> {\r\n\t\treturn this.cartItems$.pipe(map((cartItems) => cartItems?.length));\r\n\t}\r\n\t/**\r\n\t * Mapea los productos en el carrito para cambiar el precio obteniendo de la variante y seleccionando si es\r\n\t * precio de oferta o el precio normal.\r\n\t * @param items \r\n\t * @returns \r\n\t */\r\n\tprivate switchPriceInCartItem = (items: any[]) => {\r\n\t\treturn items.map(\r\n\t\t\titem => {\r\n\t\t\t\tif (item.product) {\r\n\t\t\t\t\titem.product.price = item.product.variants[0].saleprice ? item.product.variants[0].saleprice : item.product.variants[0].price;\r\n\t\t\t\t}\r\n\t\t\t\treturn item\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n\t/**\r\n\t * Actualiza la cantidad de un producto existente en el carrito.\r\n\t * @param item el item a actualizar.\r\n\t * @param quantity la cantidad nueva.\r\n\t */\r\n\tupdateItemQuantity(item: CartItem, quantity: number) {\r\n\t\tif (this.validateQuantity(item, quantity)) {\r\n\t\t\tfirstValueFrom(\r\n\t\t\t\tthis._connection.put(this.updateItemQuantityApi(this.findItemByIdVariant(item.variant_id)), { 'quantity': Number(quantity) })).then(\r\n\t\t\t\t\tres => this.updateCartObj(res) && this.updateCartItemQuantity(item.variant_id, Number(quantity)),\r\n\t\t\t\t\terr => this.handleError(err)\r\n\t\t\t\t)\r\n\t\t}\r\n\t}\r\n\t/**\r\n\t * Maneja el error en caso de que no se pueda agregar al carrito el producto.\r\n\t * @param err \r\n\t */\r\n\thandleError(err: any): void {\r\n\t\tthis._toastService.show('operation-error-param');\r\n\t\tthis._requestInProcess.next(false);\r\n\t}\r\n\t/**\r\n\t * Actualiza la cantidad del item del producto del carrito.\r\n\t * @param variantId ID de la variante para buscar el item.\r\n\t * @param quantity Nueva cantidad. \r\n\t */\r\n\tupdateCartItemQuantity(variantId: any, quantity: number): void {\r\n\t\t//console.log(\"updateCartItemQuantity\", this._items, variantId)\r\n\t\tlet newQuantity = this._items.find(item => item.variant_id == variantId).quantity = quantity;\r\n\t\tthis._cartItemsSubject.next(this._items);\r\n\t\tthis._requestInProcess.next(false);\r\n\t\tthis.updateLocalCart();\r\n\t\tthis._toastService.show('product-updated', { quantity: newQuantity });\r\n\t}\r\n\t/**\r\n\t * Actualiza los datos del carrito en el localStorage. \r\n\t */\r\n\tupdateLocalCart() {\r\n\t\tthis._storage.setItem(this.CART_KEY, this._items)\r\n\t}\r\n\t/**\r\n\t * Actualiza el carrito. Emite evento de analitics. \r\n\t * Actualiza todo lo relacionado al cupón.\r\n\t * @param cart Respuesta producida por el enpoint con información del carrito.\r\n\t * @param emitEvent \r\n\t * @returns \r\n\t */\r\n\tupdateCartObj(cart: any, emitEvent = true): boolean {\r\n\t\tthis._cartSubject.next(cart);\r\n\t\temitEvent && this._analyticsService.callEvent('add_to_cart', cart);\r\n\t\t//this._promotionsSubject.next(this.orderUtils.getPromotions(cart, true));\r\n\r\n\t\tcart.couponCode\r\n\t\t\t? this.formatCoupon(cart)\r\n\t\t\t: this._couponSubject.next(null);\r\n\t\treturn true;\r\n\t}\r\n\t/**\r\n\t * Aplicar un mejor formato a los datos de los cupones aplicados.\r\n\t * @param cart \r\n\t */\r\n\tformatCoupon(cart: any) {\r\n\t\tlet current_coupon = this._couponSubject.value;\r\n\t\tlet coupon: ICoupon = { code: cart.couponCode };\r\n\t\ttry {\r\n\t\t\tconst key = Object.keys(cart.cartDiscounts)[0];\r\n\t\t\tcoupon = {\r\n\t\t\t\t...coupon,\r\n\t\t\t\tamount: (cart.cartDiscounts && cart.cartDiscounts[key].amount.current) || 0,\r\n\t\t\t\tname: (cart.cartDiscounts && cart.cartDiscounts[key].name) || 'no-name'\r\n\t\t\t};\r\n\t\t} catch (e) { }\r\n\t\t(coupon != current_coupon) && this._couponSubject.next(coupon);\r\n\t\t//console.log(coupon);\r\n\t}\r\n\t/**\r\n\t * Retorna el ID del item del carrito.\r\n\t * @param variant_id Id de la variante utilizada para buscar el item.\r\n\t * @returns \r\n\t */\r\n\tfindItemByIdVariant(variant_id: any): any {\r\n\t\treturn this._items.find(item => item.variant_id == variant_id)!.item_id\r\n\t}\r\n\t/**\r\n\t * Valida la cantidad para saber si se puede actualizar o no.\r\n\t * @param item item del carrito\r\n\t * @param quantity cantidad a agregar\r\n\t * @returns \r\n\t */\r\n\tvalidateQuantity(item: any, quantity: any) {\r\n\t\tif ((this.getCountFromItemInCart(item.productCode) + quantity) > item.product.variants[0].maximumItemsQuantity) {\r\n\t\t\tthis._toastService.show('maximum-items-quantity', { quantity: item.product.variants[0].maximumItemsQuantity })\r\n\t\t\treturn false\r\n\t\t}\r\n\t\tif ((this.getCountFromItemInCart(item.productCode) + quantity) < item.product.variants[0].minimumItemsQuantity) {\r\n\t\t\tthis._toastService.show('minimum-items-quantity', { quantity: item.product.variants[0].minimumItemsQuantity })\r\n\t\t\treturn false\r\n\t\t}\r\n\t\treturn true\r\n\t}\r\n\t/**\r\n\t * Busca un producto a través de su ID en los items del carrito.\r\n\t * @param product_id \r\n\t * @returns\r\n\t */\r\n\tfindItem(product_id: any): any { return this._items.find((item: any) => item.product.id == product_id) }\r\n\t/**\r\n\t * Elimina un item del carrito en el backend.\r\n\t * @param item item a eliminar\r\n\t * @param toast indica si se dispara un toast  o no. Por defecto en `true`.\r\n\t */\r\n\tdeleteCartItem(item: any, toast: boolean = true) {\r\n\t\tlet idItemSearched = this.findItemByIdVariant(item.variant_id)\r\n\t\t//console.log(idItemSearched)\r\n\t\tthis._requestInProcess.next(true);\r\n\t\tfirstValueFrom(this._connection.delete(this.deleteItemApi(idItemSearched))).then(\r\n\t\t\tres => {\r\n\t\t\t\tthis.removeCartItem(res, item, toast);\r\n\t\t\t\tthis._requestInProcess.next(false);\r\n\t\t\t},\r\n\t\t\terr => {\r\n\t\t\t\tthis.handleError(err);\r\n\t\t\t\tthis._requestInProcess.next(false);\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n\t/**\r\n\t * Elimina un item en carrito de forma local. \r\n\t * @param cart Carrito, es decir, respuesta del backend.\r\n\t * @param product producto a eliminar\r\n\t * @param toast {boolean} para indicar si se dispara un toast o no. \r\n\t */\r\n\tremoveCartItem(cart: any, product: any, toast: boolean) {\r\n\t\tthis.updateCartObj(cart, false);\r\n\t\tthis._items.splice(this._items.findIndex(value => value.item_id === product.item_id), 1);\r\n\t\tthis._cartItemsSubject.next(this._items);\r\n\t\ttoast && this._requestInProcess.next(false);\r\n\t\ttoast && this._toastService.show('product-removed');\r\n\t\tthis.updateLocalCart();\r\n\t\tthis._analyticsService.callEvent('remove_from_cart', { ...product, currency: this._consts.currency.code })\r\n\t}\r\n\t/**\r\n\t * Agrega un cupon al carrito.\r\n\t * @param value Codigo del cupón.\r\n\t */\r\n\taddCoupon(value: string) {\r\n\t\tfirstValueFrom(this._connection.put(this.couponApi(), { coupon: value })).then(\r\n\t\t\tres => {\r\n\t\t\t\t//console.log(res)\r\n\t\t\t\tthis.updateCartObj(res)\r\n\t\t\t\tthis._toastService.show('Cupon aplicado')\r\n\t\t\t},\r\n\t\t\terr => {\r\n\t\t\t\t//console.error(err) \r\n\t\t\t\tthis._toastService.show('invalid-coupon')\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n\t/**\r\n\t * Elimina un cupón del carrito. \r\n\t */\r\n\tremoveCoupon() {\r\n\t\tfirstValueFrom(this._connection.delete(this.couponApi())).then(\r\n\t\t\tres => {\r\n\t\t\t\t//console.log(res)\r\n\t\t\t\tthis.updateCartObj(res)\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n\t/**\r\n\t * Retorna un observable con el subtotal del carrito.\r\n\t * @returns \r\n\t */\r\n\tgetSubTotalAmount(): Observable<number> {\r\n\t\treturn this.cart$.pipe(map((cart) => cart?.totals?.items));\r\n\t}\r\n\t/**\r\n\t * Retorna un observable con el total del monto de las promociones aplicadas.\r\n\t * @returns \r\n\t */\r\n\tgetTotalPromotionAmount(): Observable<number> {\r\n\t\treturn this.cart$.pipe(map((cart) => cart?.totals?.promotion));\r\n\t}\r\n\t/**\r\n\t * Retorna un observable con el monto de los impuestos aplicados.\r\n\t * @returns \r\n\t */\r\n\tgetTaxesAmount(): Observable<number> {\r\n\t\treturn this.cart$.pipe(map((cart) => cart?.totals?.taxes > 0 ? cart?.totals?.taxes : 0));\r\n\t}\r\n\t/**\r\n\t * Retorna un observable con el monto total del carrito.\r\n\t * @returns \r\n\t */\r\n\tgetTotalAmount() {\r\n\t\treturn this.cart$.pipe(map((cart) => cart?.totals?.total));\r\n\t}\r\n\t/**\r\n\t * Retorna el token del carrito.\r\n\t * @returns \r\n\t */\r\n\tgetCartToken() {\r\n\t\treturn this.cartToken;\r\n\t}\r\n\tchangeHaveToUpdate = (value: any) => this._haveToUpdate = value;\r\n\tclearAndResetCustomerCart() {\r\n\t\tconsole.log(\"Clearing and reseting...\")\r\n\t\tthis.resetCart(this.getCartByCustomer)\r\n\t}\r\n\r\n\tprivate getCartByCustomer = async () =>\r\n\t\tthis._connection.post(this.cartItemsApi()).subscribe(\r\n\t\t\tres => this.initializeCart(res)\r\n\t\t)\r\n\tprivate resetCart = (fn?: any) => {\r\n\t\tthis._items = [];\r\n\t\tthis._cartSubject.next(null);\r\n\t\tthis.updateBalanceAttributes(null);\r\n\t\tthis.cartToken = null;\r\n\t\tthis._cartItemsSubject.next([]);\r\n\t\tthis._count = 0;\r\n\t\tthis._localStorage.setItem(this.CART_KEY, \"[]\");\r\n\t\tthis._localStorage.removeItem(this.CART_TOKEN_KEY);\r\n\t\tfn && fn();\r\n\t}\r\n\tclearAndResetCart() {\r\n        this.resetCart(() => this.getCart);\r\n    }\r\n\r\n\tpublic updateBalanceAttributes(cartData: any) {\r\n        const balanceData = {\r\n            allowAnyPaymentMethod: cartData?.allowAnyPaymentMethod ?? false,\r\n            allowExceedBalance: cartData?.allowExceedBalance ?? false,\r\n            creditAmount: cartData?.creditAmount ?? null,\r\n            showMax: cartData?.showMax ?? false,\r\n            showPrice: cartData?.showPrice ?? false,\r\n            remainingCredits: cartData?.creditAmount && cartData?.creditAmount >= cartData?.totals.total\r\n                ? cartData?.creditAmount - cartData?.totals.total\r\n                : 0,\r\n        };\r\n\r\n        this._balanceCustomerSubject.next(balanceData);\r\n\t\tconsole.log(balanceData)\r\n    }\r\n\taddToLot(product: Product, quantity: number, variant_id: any, id?: number, order_item_id?: any, lot_quantity?: any, unit_price?: any, unit_total?: any, ajustement_total?: any, total_lot?: number, lot_status?: string, date_request?: string, notes?: string, shipping_address_id?: number, shipping_address_name?: string, action?: string){\r\n        if (!this._authService.isAbleToBuy()) {\r\n            this._toastService.show('must-select-customer')\r\n            return\r\n        }\r\n\r\n        let added = '';\r\n        !added && this._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variant_id, id: id || '', order_item_id: order_item_id || '', lot_quantity: lot_quantity || '', unit_price: unit_price || '', unit_total: unit_total || '', ajustement_total: ajustement_total || '', total_lot: total_lot || '', lot_status: lot_status || '', date_request: date_request || '', notes: notes || '', shipping_address_id: shipping_address_id || '', shipping_address_name: shipping_address_name || '', action: action || 'newlot' })\r\n            .subscribe({\r\n\t\t\t\tnext: (res) => this.appendToCart(res),\r\n\t\t\t\terror: (err) => this.handleError(err)\r\n\t\t\t});\r\n    }\r\n}\r\n"]}