ng-easycommerce-v18 0.0.1 → 0.0.3

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

@@ -0,0 +1,65 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService } from '../constants';
+import { ConnectionService } from '../api';
+import { BehaviorSubject, catchError, map, of, shareReplay } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que maneja los parametros de la aplicación.
+ */
+export class ParametersService {
+    /**
+     * Constantes de la API
+     */
+    apiConstants = inject(ApiConstantsService);
+    /**
+     * Maneja las peticiones a la API
+     */
+    connection = inject(ConnectionService);
+    //API URLS
+    /**
+     * Devuelve la URL para obtener todos los parametros.
+     * @returns
+     */
+    getAllParametersAPI() { return `${this.apiConstants.SHOP_API_URL}${this.apiConstants.CHANNEL}/parameters`; }
+    //OBSERVABLES
+    /**
+     * Subject para manejar los cambios en los datos de los parametros
+     */
+    parametersSubject = new BehaviorSubject(null);
+    parameters$ = this.parametersSubject.asObservable();
+    //METHODS
+    /**
+     * Obtiene los parámetros del backend.
+     * @returns
+     */
+    getParameters() {
+        if (this.parametersSubject.getValue() === null) {
+            this.connection.get(this.getAllParametersAPI()).pipe(shareReplay(1), map((response) => {
+                this.parametersSubject.next(response);
+                return response;
+            }), catchError((error) => {
+                console.log(`Error: ${error}`);
+                this.parametersSubject.next([]);
+                return of([]);
+            })).subscribe();
+        }
+        return this.parameters$;
+    }
+    /**
+     * Comprueba si el código de un parámetro existe en la lista de parámetros.
+     * @param params Lista de parámetros
+     * @param code Código del parámetro a buscar
+     * @returns El objeto con los datos del parámetro encontrado, sino retorna `null`
+     */
+    hasParams(params, code) { return params && params.find((param) => param.code?.toLowerCase().includes(code.toLowerCase())); }
+    constructor() { }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ParametersService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ParametersService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ParametersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,54 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, firstValueFrom, map } from 'rxjs';
+import { ConnectionService } from '../api';
+import { ToastService } from './toast.service';
+import { ApiConstantsService } from '../constants';
+import { CartService } from './cart.service';
+import { AnalyticsService } from './analytics';
+import { CheckoutService } from './checkout.service';
+import * as i0 from "@angular/core";
+export class PaymentService {
+    _connectionService = inject(ConnectionService);
+    _toastService = inject(ToastService);
+    _apiConsts = inject(ApiConstantsService);
+    _cartService = inject(CartService);
+    _analyticsService = inject(AnalyticsService);
+    _checkoutService = inject(CheckoutService);
+    paymentMethodsSubject = new BehaviorSubject([]);
+    methods$ = this.paymentMethodsSubject.asObservable();
+    //API URL
+    baseApi() { return 'shop-api/' + this._apiConsts.CHANNEL + '/' + 'checkout/' + this._cartService.getCartToken(); }
+    getPaymentMethodsApi() { return this.baseApi() + '/payment'; }
+    putPaymentApi(method) { return this.baseApi() + '/payment/' + method; }
+    getPreferenceApi() { return 'shop-api/' + this._apiConsts.CHANNEL + '/mercado-pago/' + this._cartService.getCartToken() + '/preference'; }
+    constructor() {
+        this.getPaymentMethods();
+    }
+    getPaymentMethods() {
+        return firstValueFrom(this._connectionService.get(this.getPaymentMethodsApi())).then(res => res.payments?.length && this.paymentMethodsSubject.next(Object.keys(res.payments[0].methods).map(key => res.payments[0].methods[key])), err => this._toastService.show('operation-error'));
+    }
+    putPayment(method) {
+        return firstValueFrom(this._connectionService
+            .put(this.putPaymentApi(method), { method })).then(res => {
+            this._analyticsService.callEvent('add_payment_info', res);
+            return res;
+        }, err => {
+            return new Promise((resolve, reject) => reject(new Error(err.error)));
+        }).catch(err => console.error(err));
+    }
+    getPreference(shipment_data) {
+        return firstValueFrom(this._connectionService.post(this.getPreferenceApi(), shipment_data).pipe(map(res => (res.preference || res))));
+    }
+    setPayment(data) {
+        return this._checkoutService.setStepData('payment', data);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: PaymentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: PaymentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: PaymentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ec-services/product-detail.service.mjs

@@ -0,0 +1,285 @@
+import { inject, Injectable } from '@angular/core';
+import { ProductsService } from './products.service';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { ToastService } from './toast.service';
+import { CartService } from './cart.service';
+import * as i0 from "@angular/core";
+export class ProductDetailService {
+    _productsService = inject(ProductsService);
+    _toastService = inject(ToastService);
+    _cartService = inject(CartService);
+    _productSubject = new BehaviorSubject({});
+    _optionsSubject = new BehaviorSubject({});
+    _associatedDataSubject = new BehaviorSubject({ price: '', stock: 0, picture: '' });
+    product$ = this._productSubject.asObservable();
+    options$ = this._optionsSubject.asObservable();
+    associatedData$ = this._associatedDataSubject.asObservable();
+    variants = [];
+    constructor() { }
+    /**
+     * Obtengo el producto a traves de su codigo e inicializo la configuración
+     * del Servicio.
+     * @param code
+     * @param variant
+     */
+    loadProduct(code, variant = false) {
+        firstValueFrom(this._productsService.getProductByCode(code, variant))
+            .then(res => {
+            variant ? this.initialize(res, code) : this.initialize(res);
+        })
+            .catch(err => { console.log(err); this._productSubject.next(null); });
+    }
+    /**
+     * Carga el producto en el observable y la configuración de las variantes.
+     * @param product
+     * @param variantCode
+     */
+    initialize(product, variantCode) {
+        this._productSubject.next(product);
+        const aux = product.options || [];
+        const options = aux?.map(option => this.toOption(option));
+        this._optionsSubject.next(options);
+        variantCode ? this.updateVariants(variantCode) : this.updateVariants();
+        this.variants.length && this.generateAssociatedDataFromVariants();
+    }
+    /**
+     * Formate los datos para las opciones del producto.
+     * @param option
+     * @returns
+     */
+    toOption(option) {
+        return {
+            name: option.label,
+            code: option.code,
+            type: option.type,
+            values: option.values.map((value) => ({ name: value.code, description: value.name, image: value.image, mobileImage: value.mobileImage, selected: false }))
+        };
+    }
+    /**
+     * Cambia las opciones, obtiene el producto asociado a la opcion elegida.
+     */
+    setOption(optionCode, optionValue) {
+        const options = this._optionsSubject.value;
+        const option = options.find((element) => element.code == optionCode).values.find((value) => value.name == optionValue);
+        option.selected = !option.selected;
+        options.find((element) => element.code == optionCode).values.forEach((value) => { if (value.name != option.name)
+            value.selected = false; });
+        this._optionsSubject.next(options);
+        this.updateVariants();
+        this.variants.length > 0 ? this.generateAssociatedDataFromVariants() : this._toastService.show('selection-not-available');
+    }
+    /**
+     * Actualiza el observable de `associatedData` el cual se utiliza para mostrar los datos
+     * en el frontend segun el producto y/o variante elegida.
+     * Obtiene los datos de la variante y los formatea.
+     */
+    generateAssociatedDataFromVariants() {
+        let associated = {};
+        if (this.variants.length == 1) {
+            const variant = this.variants[0];
+            console.log(variant);
+            associated.stock = variant.stock;
+            associated.price = variant.price.toString();
+            associated.saleprice = variant.saleprice && variant.saleprice.toString() || undefined;
+            associated.discount = variant?.discount || undefined;
+            associated.properties = variant.properties ? this.beautifyProperties(variant.properties) : undefined;
+            associated.uniqueExternalCode = variant?.uniqueExternalCode || undefined;
+            associated.multipleQuantity = variant?.multipleQuantity || undefined;
+        }
+        else {
+            associated.price = this.createPrice();
+            associated.saleprice = this.createSalePrice();
+            associated.stock = (this.variants.map(variant => variant.stock)).reduce((a, b) => a + b);
+            associated.discount = this.createDiscount();
+        }
+        ('images' in this.variants[0] && this.variants[0].images.length > 0)
+            ? associated.picture = this.variants[0].images[0]
+            : associated.picture = (this._associatedDataSubject.value?.picture || (this._productSubject.value && this._productSubject.value?.picturesdefault?.[0] || []));
+        associated.maximumAmount = this.variants[0]?.maximumAmount || 0;
+        associated.minimumAmount = this.variants[0]?.minimumAmount || 0;
+        associated.maximumItemsQuantity = this.variants[0]?.stock > 0 && 'maximumItemsQuantity' in this.variants[0] ? this.variants[0]?.maximumItemsQuantity : this.variants[0]?.stock;
+        associated.minimumItemsQuantity = this.variants[0]?.stock > 0 && 'minimumItemsQuantity' in this.variants[0]
+            && this.variants[0]?.minimumItemsQuantity > 0 ? this.variants[0]?.minimumItemsQuantity
+            : (this.variants[0]?.multipleQuantity ? this.variants[0]?.multipleQuantity : 1);
+        associated.finalConsumer = {
+            finalConsumerPrice: this.variants[0]?.final_consumer_price,
+            originalFinalConsumerPrice: this.variants[0]?.original_final_consumer_price,
+        };
+        associated.taxes = {
+            taxIncluded: this.variants[0]?.taxIncluded,
+            taxCategory: this.variants[0]?.taxCategory,
+        };
+        //console.log(associated)
+        this._associatedDataSubject.next(associated);
+    }
+    /**
+     * Mejora los datos de las `properties`.
+     * @param properties
+     * @returns
+     */
+    beautifyProperties(properties) {
+        let beautifyData = [];
+        properties.forEach((prop) => {
+            for (let key in prop) {
+                beautifyData.push({ name: key, value: prop[key] });
+            }
+        });
+        return beautifyData;
+    }
+    /**
+     * Devuelve un descuento en caso de existir.
+     * @returns
+     */
+    createDiscount() {
+        let allDiscounts = '';
+        this.variants.forEach(variant => {
+            variant.discount && (allDiscounts += ', ' + variant.discount);
+        });
+        if (allDiscounts == '')
+            return undefined;
+        return allDiscounts;
+    }
+    /**
+     * Devuelve el precio de venta.
+     * @returns
+     */
+    createSalePrice() {
+        let minPrice = 0;
+        let maxPrice = 0;
+        let allPrices = this.variants.map(v => v.saleprice).filter(e => e !== undefined);
+        if (allPrices.length == 0) {
+            return undefined;
+        }
+        minPrice = allPrices.reduce((a, b) => Math.min(a, b));
+        maxPrice = allPrices.reduce((a, b) => Math.max(a, b));
+        return minPrice == maxPrice ? maxPrice.toString() : minPrice + ' - ' + maxPrice;
+    }
+    /**
+     * Devuelve el precio o los precios en caso de tener varias variantes con distintos precios.
+     * @returns
+     */
+    createPrice() {
+        let minPrice = 0;
+        let maxPrice = 0;
+        let allPrice = this.variants.map(v => v.price);
+        minPrice = allPrice.reduce((a, b) => Math.min(a, b));
+        maxPrice = allPrice.reduce((a, b) => Math.max(a, b));
+        return minPrice == maxPrice ? maxPrice.toString() : minPrice + ' - ' + maxPrice;
+    }
+    /**
+     * Actualiza las variantes.
+     * @param code
+     */
+    updateVariants = (code) => {
+        let variants = this._productSubject.value?.variants;
+        //console.log(variants)
+        if (!code) {
+            this._optionsSubject.value.forEach((option) => {
+                option.values.forEach((value) => {
+                    if (value.selected) {
+                        variants = variants?.filter(variant => {
+                            return variant.options.some((variantOption) => {
+                                return (option.code in variantOption && variantOption[option.code] == value.name);
+                            });
+                        });
+                    }
+                });
+            });
+        }
+        else {
+            variants = variants?.filter(variant => variant.code == code);
+        }
+        this.variants = variants || [];
+        code && this.updateOptions();
+    };
+    /**
+     * Actualiza las opciones
+     */
+    updateOptions = () => {
+        let { options } = this.variants.length && this.variants[0];
+        options && options.forEach((option) => Object.keys(option).forEach(key => this.setOption(key, option[key])));
+    };
+    /**
+     * Agrega el producto al carrito.
+     * @param quantity Cantidad del producto a agregar
+     * @param variantCode Codigo de la variante.
+     * @returns
+     */
+    addToCart(quantity, variantCode) {
+        if (!this.variants.length) {
+            this._toastService.show('cant-buy');
+            return;
+        }
+        let productSelected = JSON.parse(JSON.stringify((this._productSubject.getValue())));
+        let variant;
+        switch (this.variants.length) {
+            case 0:
+                this._toastService.show('no-variants');
+                break;
+            case 1:
+                this._associatedDataSubject.value.stock == 0
+                    ? this._toastService.show('out-of-stock')
+                    : variant = this.variants[0];
+                break;
+            default:
+                if (variantCode) {
+                    variant = this.variants.find(variant => variant.code === variantCode);
+                    if (variant.stock == 0) {
+                        this._toastService.show('out-of-stock');
+                        variant = undefined;
+                    }
+                }
+                else {
+                    this._toastService.show('variants-left');
+                }
+                break;
+        }
+        if (!variant)
+            return;
+        if (!this.validateQuantity(quantity))
+            return;
+        //agregar al servicio del carrito
+        this._cartService.addToCart(this.makeAffordableProduct(productSelected), quantity, variant.code);
+    }
+    /**
+     * Genera un producto para hacer mas facíl el envio del elemento al backend.
+     * @param productSelected
+     * @returns
+     */
+    makeAffordableProduct(productSelected) {
+        productSelected.price = parseFloat(this._associatedDataSubject.value.price);
+        productSelected.saleprice = parseFloat(this._associatedDataSubject.value.price);
+        productSelected.options = [];
+        this.variants[0].options.forEach((option) => productSelected.options = { ...productSelected.options, ...option });
+        return productSelected;
+    }
+    /**
+     * Valida la cantidad que se quiere agregar de un producto.
+     * Revisa que no supere el stock, el maximo de items que se puede agregar
+     * asi como el minimo.
+     * @param quantity
+     * @returns
+     */
+    validateQuantity = (quantity) => {
+        const actualQuantity = this._cartService.getCountFromItemInCart(this.variants[0].code);
+        const asociatedData = this._associatedDataSubject.value;
+        if ((actualQuantity + quantity) > asociatedData.maximumItemsQuantity) {
+            this._toastService.show('maximum-items-quantity', { quantity: asociatedData.maximumItemsQuantity });
+            return false;
+        }
+        if ((actualQuantity + quantity) < asociatedData.minimumItemsQuantity) {
+            this._toastService.show('minimum-items-quantity', { quantity: asociatedData.minimumItemsQuantity });
+            return false;
+        }
+        return true;
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductDetailService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductDetailService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductDetailService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-detail.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/product-detail.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { ProductsService } from './products.service';\r\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\r\nimport { Options, OptionValue, Product } from '../interfaces';\r\nimport { ToastService } from './toast.service';\r\nimport { CartService } from './cart.service';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ProductDetailService {\r\n\tprivate _productsService: ProductsService = inject(ProductsService);\r\n\tprivate _toastService: ToastService = inject(ToastService);\r\n\tprivate _cartService: CartService = inject(CartService);\r\n\r\n\tprivate _productSubject = new BehaviorSubject<Product | null>({});\r\n\tprivate _optionsSubject = new BehaviorSubject<any>({});\r\n\tprivate _associatedDataSubject = new BehaviorSubject<any>({ price: '', stock: 0, picture: '' });\r\n\r\n\tpublic product$ = this._productSubject.asObservable();\r\n\tpublic options$ = this._optionsSubject.asObservable();\r\n\tpublic associatedData$ = this._associatedDataSubject.asObservable();\r\n\r\n\tprivate variants: any[] = []\r\n\r\n\tconstructor() { }\r\n\t/**\r\n\t * Obtengo el producto a traves de su codigo e inicializo la configuración\r\n\t * del Servicio.\r\n\t * @param code \r\n\t * @param variant \r\n\t */\r\n\tloadProduct(code: string, variant: boolean = false) {\r\n\t\tfirstValueFrom(this._productsService.getProductByCode(code, variant))\r\n\t\t\t.then(res => {\r\n\t\t\t\tvariant ? this.initialize(res, code) : this.initialize(res)\r\n\t\t\t})\r\n\t\t\t.catch(err => { console.log(err); this._productSubject.next(null) });\r\n\t}\r\n\t/**\r\n\t * Carga el producto en el observable y la configuración de las variantes.\r\n\t * @param product \r\n\t * @param variantCode \r\n\t */\r\n\tprivate initialize(product: Product, variantCode?: string) {\r\n\t\tthis._productSubject.next(product);\r\n\t\tconst aux: Product['options'] = product.options || [];\r\n\t\tconst options = aux?.map(option => this.toOption(option))\r\n\t\tthis._optionsSubject.next(options);\r\n\t\tvariantCode ? this.updateVariants(variantCode) : this.updateVariants();\r\n\t\tthis.variants.length && this.generateAssociatedDataFromVariants();\r\n\t}\r\n\t/**\r\n\t * Formate los datos para las opciones del producto.\r\n\t * @param option \r\n\t * @returns \r\n\t */\r\n\tprivate toOption(option: Options) {\r\n\t\treturn {\r\n\t\t\tname: option.label,\r\n\t\t\tcode: option.code,\r\n\t\t\ttype: option.type,\r\n\t\t\tvalues: option.values.map((value: any) => ({ name: value.code, description: value.name, image: value.image, mobileImage: value.mobileImage, selected: false }))\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * Cambia las opciones, obtiene el producto asociado a la opcion elegida.\r\n\t */\r\n\tsetOption(optionCode: any, optionValue: any) {\r\n\t\tconst options = this._optionsSubject.value;\r\n\t\tconst option = options.find((element: any) => element.code == optionCode).values.find((value: any) => value.name == optionValue);\r\n\t\toption.selected = !option.selected;\r\n\t\toptions.find((element: any) => element.code == optionCode).values.forEach(\r\n\t\t\t(value: any) => { if (value.name != option.name) value.selected = false }\r\n\t\t);\r\n\t\tthis._optionsSubject.next(options);\r\n\t\tthis.updateVariants();\r\n\t\tthis.variants.length > 0 ? this.generateAssociatedDataFromVariants() : this._toastService.show('selection-not-available')\r\n\t}\r\n\t/**\r\n\t * Actualiza el observable de `associatedData` el cual se utiliza para mostrar los datos\r\n\t * en el frontend segun el producto y/o variante elegida.\r\n\t * Obtiene los datos de la variante y los formatea.\r\n\t */\r\n\tgenerateAssociatedDataFromVariants() {\r\n\t\tlet associated: any = {};\r\n\t\tif (this.variants.length == 1) {\r\n\t\t\tconst variant = this.variants[0];\r\n\t\t\tconsole.log(variant)\r\n\t\t\tassociated.stock = variant.stock\r\n\t\t\tassociated.price = variant.price.toString();\r\n\t\t\tassociated.saleprice = variant.saleprice && variant.saleprice.toString() || undefined;\r\n\t\t\tassociated.discount = variant?.discount || undefined;\r\n\t\t\tassociated.properties = variant.properties ? this.beautifyProperties(variant.properties) : undefined;\r\n\t\t\tassociated.uniqueExternalCode = variant?.uniqueExternalCode || undefined;\r\n\t\t\tassociated.multipleQuantity = variant?.multipleQuantity || undefined;\r\n\t\t} else {\r\n\t\t\tassociated.price = this.createPrice()\r\n\t\t\tassociated.saleprice = this.createSalePrice()\r\n\t\t\tassociated.stock = (this.variants.map(variant => variant.stock)).reduce((a, b) => a + b)\r\n\t\t\tassociated.discount = this.createDiscount()\r\n\t\t}\r\n\r\n\t\t('images' in this.variants[0] && this.variants[0].images.length > 0)\r\n\t\t\t? associated.picture = this.variants[0].images[0]\r\n\t\t\t: associated.picture = (this._associatedDataSubject.value?.picture || (this._productSubject.value && this._productSubject.value?.picturesdefault?.[0] || []));\r\n\r\n\t\tassociated.maximumAmount = this.variants[0]?.maximumAmount || 0\r\n\t\tassociated.minimumAmount = this.variants[0]?.minimumAmount || 0\r\n\r\n\t\tassociated.maximumItemsQuantity = this.variants[0]?.stock > 0 && 'maximumItemsQuantity' in this.variants[0] ? this.variants[0]?.maximumItemsQuantity : this.variants[0]?.stock\r\n\t\tassociated.minimumItemsQuantity = this.variants[0]?.stock > 0 && 'minimumItemsQuantity' in this.variants[0]\r\n\t\t\t&& this.variants[0]?.minimumItemsQuantity > 0 ? this.variants[0]?.minimumItemsQuantity\r\n\t\t\t: (this.variants[0]?.multipleQuantity ? this.variants[0]?.multipleQuantity : 1)\r\n\r\n\t\tassociated.finalConsumer = {\r\n\t\t\tfinalConsumerPrice: this.variants[0]?.final_consumer_price,\r\n\t\t\toriginalFinalConsumerPrice: this.variants[0]?.original_final_consumer_price,\r\n\t\t}\r\n\t\tassociated.taxes = {\r\n\t\t\ttaxIncluded: this.variants[0]?.taxIncluded,\r\n\t\t\ttaxCategory: this.variants[0]?.taxCategory,\r\n\t\t}\r\n\t\t//console.log(associated)\r\n\t\tthis._associatedDataSubject.next(associated);\r\n\t}\r\n\t/**\r\n\t * Mejora los datos de las `properties`.\r\n\t * @param properties \r\n\t * @returns \r\n\t */\r\n\tbeautifyProperties(properties: any): any {\r\n\t\tlet beautifyData: any = [];\r\n\t\tproperties.forEach((prop: any) => {\r\n\t\t\tfor (let key in prop) {\r\n\t\t\t\tbeautifyData.push({ name: key, value: prop[key] })\r\n\t\t\t}\r\n\t\t})\r\n\t\treturn beautifyData\r\n\t}\r\n\t/**\r\n\t * Devuelve un descuento en caso de existir.\r\n\t * @returns \r\n\t */\r\n\tcreateDiscount(): any {\r\n\t\tlet allDiscounts: string = '';\r\n\t\tthis.variants.forEach(variant => {\r\n\t\t\tvariant.discount && (allDiscounts += ', ' + variant.discount);\r\n\t\t})\r\n\t\tif (allDiscounts == '') return undefined;\r\n\t\treturn allDiscounts;\r\n\t}\r\n\t/**\r\n\t * Devuelve el precio de venta.\r\n\t * @returns \r\n\t */\r\n\tcreateSalePrice(): any {\r\n\t\tlet minPrice: number = 0;\r\n\t\tlet maxPrice: number = 0;\r\n\t\tlet allPrices: any = this.variants.map(v => v.saleprice).filter(e => e !== undefined);\r\n\t\tif (allPrices.length == 0) {\r\n\t\t\treturn undefined\r\n\t\t}\r\n\t\tminPrice = allPrices.reduce((a: number, b: number) => Math.min(a, b));\r\n\t\tmaxPrice = allPrices.reduce((a: number, b: number) => Math.max(a, b));\r\n\t\treturn minPrice == maxPrice ? maxPrice.toString() : minPrice + ' - ' + maxPrice;\r\n\t}\r\n\t/**\r\n\t * Devuelve el precio o los precios en caso de tener varias variantes con distintos precios.\r\n\t * @returns \r\n\t */\r\n\tcreatePrice(): any {\r\n\t\tlet minPrice: number = 0;\r\n\t\tlet maxPrice: number = 0;\r\n\t\tlet allPrice: any = this.variants.map(v => v.price)\r\n\t\tminPrice = allPrice.reduce((a: number, b: number) => Math.min(a, b));\r\n\t\tmaxPrice = allPrice.reduce((a: number, b: number) => Math.max(a, b));\r\n\t\treturn minPrice == maxPrice ? maxPrice.toString() : minPrice + ' - ' + maxPrice;\r\n\t}\r\n\t/**\r\n\t * Actualiza las variantes.\r\n\t * @param code \r\n\t */\r\n\tupdateVariants = (code?: string) => {\r\n\t\tlet variants = this._productSubject.value?.variants\r\n\t\t//console.log(variants)\r\n\t\tif (!code) {\r\n\t\t\tthis._optionsSubject.value.forEach((option: any) => {\r\n\t\t\t\toption.values.forEach((value: any) => {\r\n\t\t\t\t\tif (value.selected) {\r\n\t\t\t\t\t\tvariants = variants?.filter(variant => {\r\n\t\t\t\t\t\t\treturn variant.options.some((variantOption: any) => {\r\n\t\t\t\t\t\t\t\treturn (option.code in variantOption && variantOption[option.code] == value.name);\r\n\t\t\t\t\t\t\t})\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\t})\r\n\t\t} else {\r\n\t\t\tvariants = variants?.filter(variant => variant.code == code);\r\n\t\t}\r\n\t\tthis.variants = variants || [];\r\n\t\tcode && this.updateOptions();\r\n\t}\r\n\t/**\r\n\t * Actualiza las opciones\r\n\t */\r\n\tprivate updateOptions = () => {\r\n\t\tlet { options } = this.variants.length && this.variants[0];\r\n\t\toptions && options.forEach((option: any) => Object.keys(option).forEach(key => this.setOption(key, option[key])))\r\n\t}\r\n\t/**\r\n\t * Agrega el producto al carrito.\r\n\t * @param quantity Cantidad del producto a agregar\r\n\t * @param variantCode Codigo de la variante.\r\n\t * @returns \r\n\t */\r\n\taddToCart(quantity: number, variantCode?: string){\r\n\r\n\t\tif(!this.variants.length){\r\n\t\t\tthis._toastService.show('cant-buy')\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tlet productSelected = JSON.parse(JSON.stringify((this._productSubject.getValue())));\r\n\r\n\t\tlet variant:any;\r\n\r\n\t\tswitch(this.variants.length){\r\n\t\t\tcase 0:\r\n\t\t\t\tthis._toastService.show('no-variants');\r\n\t\t\t\tbreak;\r\n\t\t\tcase 1:\r\n\t\t\t\tthis._associatedDataSubject.value.stock == 0\r\n\t\t\t\t\t? this._toastService.show('out-of-stock')\r\n\t\t\t\t\t: variant = this.variants[0]\r\n\t\t\t\tbreak;\r\n\t\t\tdefault:\r\n\t\t\t\tif(variantCode){\r\n\t\t\t\t\tvariant = this.variants.find( variant =>  variant.code === variantCode)\r\n\t\t\t\t\tif(variant.stock == 0){\r\n\t\t\t\t\t\tthis._toastService.show('out-of-stock')\r\n\t\t\t\t\t\tvariant = undefined\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis._toastService.show('variants-left')\r\n\t\t\t\t}\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\t\tif(!variant) return;\r\n\t\tif(!this.validateQuantity(quantity)) return;\r\n\r\n\t\t//agregar al servicio del carrito\r\n\t\tthis._cartService.addToCart(this.makeAffordableProduct(productSelected), quantity, variant.code);\r\n\t}\r\n\t/**\r\n\t * Genera un producto para hacer mas facíl el envio del elemento al backend.\r\n\t * @param productSelected \r\n\t * @returns \r\n\t */\r\n\tprivate makeAffordableProduct(productSelected: Product) {\r\n        productSelected.price = parseFloat(this._associatedDataSubject.value.price);\r\n        productSelected.saleprice = parseFloat(this._associatedDataSubject.value.price);\r\n\t\tproductSelected.options = [];\r\n        this.variants[0].options.forEach((option:any) => productSelected.options = { ...productSelected.options, ...option })\r\n        return productSelected;\r\n    }\r\n\t/**\r\n\t * Valida la cantidad que se quiere agregar de un producto.\r\n\t * Revisa que no supere el stock, el maximo de items que se puede agregar\r\n\t * asi como el minimo.\r\n\t * @param quantity \r\n\t * @returns \r\n\t */\r\n\tprivate validateQuantity = (quantity: number) => {\r\n        const actualQuantity = this._cartService.getCountFromItemInCart(this.variants[0].code);\r\n        const asociatedData = this._associatedDataSubject.value;\r\n        if ((actualQuantity + quantity) > asociatedData.maximumItemsQuantity) {\r\n            this._toastService.show('maximum-items-quantity', { quantity: asociatedData.maximumItemsQuantity })\r\n            return false;\r\n        }\r\n        if ((actualQuantity + quantity) < asociatedData.minimumItemsQuantity) {\r\n            this._toastService.show('minimum-items-quantity', { quantity: asociatedData.minimumItemsQuantity })\r\n            return false;\r\n        }\r\n        return true\r\n    }\r\n}\r\n"]}