ng-easycommerce-v18 0.0.1 → 0.0.2

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

@@ -0,0 +1,148 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { ConnectionService } from '../api';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { OptionsService } from './options.service';
+import { PaginationService } from './pagination.service';
+import { FiltersService } from './filters.service';
+import * as i0 from "@angular/core";
+export class ProductsService {
+    _connection = inject(ConnectionService);
+    _apiConsts = inject(ApiConstantsService);
+    _optionsService = inject(OptionsService);
+    _paginationService = inject(PaginationService);
+    _consts = inject(CoreConstantsService);
+    _productsSubject = new BehaviorSubject([]);
+    products$ = this._productsSubject.asObservable();
+    _filtersService = inject(FiltersService);
+    searchValue = signal('');
+    constructor() {
+        this._paginationService.reset$.subscribe(res => {
+            this._productsSubject.next([]);
+        });
+        this._paginationService.paginationData$.subscribe(products => {
+            const productsWithUniqueVariant = this._consts.getProductWithUniqueVariant();
+            if (productsWithUniqueVariant)
+                products = this.getProductsWithUniqueVariant(products, this.getObjectWithVariant());
+            const currentProducts = this._productsSubject.value;
+            this._productsSubject.next([...currentProducts, ...products]);
+        });
+    }
+    //API URL
+    _shopApiUrl = this._apiConsts.SHOP_API_URL;
+    productByCodeApi(code, variant) { return this._shopApiUrl + this._apiConsts.CHANNEL + '/products/by-code/' + (variant ? 'variant/' : '') + code + '?locale=' + this._apiConsts.LOCALE; }
+    /**
+     * Setea los filtros para obtener los productos.
+     * @param paginationSettings
+     * @param searchValue
+     */
+    getProductsForFilter(paginationSettings, searchValue) {
+        searchValue ? this.searchValue.set(searchValue) : this.searchValue.set('');
+        paginationSettings && this._filtersService.setFilters(paginationSettings);
+    }
+    /**
+     * Actualiza los productos con los de la siguiente pagina.
+     */
+    updateProducts() {
+        if (!this._paginationService.getWaiting()) {
+            this._paginationService.getNext();
+        }
+    }
+    /**
+     * Devuelve el producto por codigo.
+     * @param code Codigo del producto
+     * @param variant Para indicar si es variante o no.
+     * @returns
+     */
+    getProductByCode(code, variant) {
+        return this._connection.get(this.productByCodeApi(code, variant));
+    }
+    /**
+     * Recibe una lista de productos y retorna los mismos productos tantas veces como variantes tenga.
+     * cada producto retornado tendrá una única variante.
+     * @param products  Array. Lista de productos.
+     * @param withOption 'type' tipo de opción, code: código de la opción. 'defaultFirstOption': en caso de que no se pueda desdoblar por la opción indicada si el valor es verdadero se intentara desdoblar por la primera opción asociada al producto.
+     * 'checkIfStock': en caso de que esta valor sea verdadero se realiza un control de que la variantes cuenten con stock para ser un producto desdoblado por la variante, si el valor es falso no se realiza dicho control y el producto se desdoblara con stock en 0.
+     * @returns arreglo con los productos desdoblados por la opción solicitada.
+     * (opción por defecto que se intenta hacer el desdoblamiento 'color', o bien si en le parámetro withOption el atributo 'defaultFirstOption' es verdadero se desdobla por la primera opción asociada al producto)
+     */
+    getProductsWithUniqueVariant = (products, withOption = { type: 'color', code: 'color', defaultFirstOption: false, checkIfStock: true }) => {
+        !withOption['code'] && withOption['type'] && (withOption['code'] = withOption['type']) || !withOption['code'] && (withOption['code'] = 'color');
+        !withOption['type'] && withOption['code'] && (withOption['type'] = withOption['code']) || !withOption['type'] && (withOption['type'] = 'color');
+        !withOption.hasOwnProperty('defaultFirstOption') && (withOption['defaultFirstOption'] = false);
+        !withOption.hasOwnProperty('checkIfStock') && (withOption['checkIfStock'] = true);
+        let productsUniqueVariant = [];
+        products.forEach((product) => {
+            let variants = [...product?.variants];
+            let option = product.options.find((opt) => opt.type.toLowerCase() === withOption.type?.toLowerCase());
+            if (option) {
+                option.values.forEach((optionValue) => {
+                    let modified_product = JSON.parse(JSON.stringify(product));
+                    modified_product.options.find((option) => option.type.toLowerCase() == withOption.type?.toLowerCase()).values = [{ code: optionValue.code, name: optionValue.name }];
+                    //busco una variante con ese code para asignarle la lista de imagenes
+                    let variantAux = variants.find(variant => ((withOption.checkIfStock && variant.stock > 0) || withOption.checkIfStock == false)
+                        && variant.options.length
+                        && variant.options.some((op) => (op.hasOwnProperty(withOption.code?.toLowerCase()) || op.hasOwnProperty(withOption.code?.toUpperCase()))
+                            && (op[`${withOption.code?.toLowerCase()}`] || op[`${withOption.code?.toUpperCase()}`]) === optionValue.code));
+                    //console.log("---",variantAux);
+                    variantAux && productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue));
+                });
+            }
+            else {
+                /**
+                 * se modifica el caso para cuando se toma el primer `option` del producto para
+                 * armar la lista de productos con variantes.
+                 */
+                if (withOption.defaultFirstOption && product.options?.length) {
+                    let firstOptions = product.options[0];
+                    product.options[0].values.forEach((optionValue) => {
+                        let modified_product = JSON.parse(JSON.stringify(product));
+                        modified_product.options.find((option) => option.type == firstOptions.type).values = [{ code: optionValue.code, name: optionValue.name }];
+                        let variantAux = variants.find(variant => {
+                            return variant.options.find((elem) => elem[firstOptions.code] == optionValue.code);
+                        });
+                        if (variantAux && variantAux.images.length == 0) {
+                            variantAux.images = product.picturesdefault;
+                        }
+                        if (withOption.checkIfStock) {
+                            (variantAux && variantAux.stock > 0) ? productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue)) : null;
+                        }
+                        else {
+                            variantAux && productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue));
+                        }
+                    });
+                }
+                else {
+                    productsUniqueVariant.push(product);
+                }
+            }
+        });
+        return productsUniqueVariant.length > 0 ? productsUniqueVariant : products;
+    };
+    productWithVariantValues = (product, variant, optionValue) => {
+        product.picturesdefault = [...variant.images];
+        product.variant_id = variant.code; //lo dejo aca hasta asegurarnos de que no se estaba usando en otra parte.
+        product.stock = variant.stock || 0; //lo dejo aca hasta asegurarnos de que no se estaba usando en otra parte.
+        product.price = variant.price.toString() || '0';
+        product.currentOption = {
+            ...optionValue,
+            productCode: product.id,
+            variantCode: variant.code,
+            stock: variant.stock || 0,
+            finalPrice: variant.saleprice || variant.price || 0,
+        };
+        return product;
+    };
+    getObjectWithVariant = () => {
+        return this._consts.getParamsProductsWithUniqueVariant();
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ProductsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"products.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/products.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EnvironmentInjector, inject, Injectable, runInInjectionContext, signal } from '@angular/core';\nimport { BehaviorSubject, map, Observable, ReplaySubject, shareReplay, switchMap } from 'rxjs';\nimport { DefaultFilter, FilterElement, FilterType, IFilter, Options, PaginationSettings, ParamsProductsWithUniqueVariant, Product } from '../interfaces';\nimport { ConnectionService } from '../api';\nimport { ApiConstantsService, CoreConstantsService } from '../constants';\nimport { OptionsService } from './options.service';\nimport { PaginationService } from './pagination.service';\nimport { Filter, FilterFactory } from '../classes';\nimport { FiltersService } from './filters.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ProductsService {\n    private _connection: ConnectionService = inject(ConnectionService);\n    private _apiConsts: ApiConstantsService = inject(ApiConstantsService);\n    private _optionsService: OptionsService = inject(OptionsService);\n    private _paginationService: PaginationService = inject(PaginationService);\n    private _consts: CoreConstantsService = inject(CoreConstantsService);\n\n    private _productsSubject: BehaviorSubject<Product[]> = new BehaviorSubject<Product[]>([])\n    public products$: Observable<Product[]> = this._productsSubject.asObservable();\n    private _filtersService: FiltersService = inject(FiltersService)\n\n    private searchValue = signal<string>('');\n\n    constructor() {\n        this._paginationService.reset$.subscribe(res => {\n            this._productsSubject.next([])\n        })\n        this._paginationService.paginationData$.subscribe(\n            products => {\n                const productsWithUniqueVariant = this._consts.getProductWithUniqueVariant();\n                if (productsWithUniqueVariant)\n                    products = this.getProductsWithUniqueVariant(products, this.getObjectWithVariant())\n                const currentProducts = this._productsSubject.value;\n                this._productsSubject.next([...currentProducts, ...products]);\n            }\n        )\n    }\n\n    //API URL\n    private _shopApiUrl = this._apiConsts.SHOP_API_URL;\n    productByCodeApi(code: string, variant: boolean) { return this._shopApiUrl + this._apiConsts.CHANNEL + '/products/by-code/' + (variant ? 'variant/' : '') + code + '?locale=' + this._apiConsts.LOCALE; }\n\n    /**\n     * Setea los filtros para obtener los productos.\n     * @param paginationSettings \n     * @param searchValue \n     */\n    getProductsForFilter(paginationSettings?: PaginationSettings, searchValue?: any): any {\n        searchValue ? this.searchValue.set(searchValue) : this.searchValue.set('');\n        paginationSettings && this._filtersService.setFilters(paginationSettings)\n    }\n    /**\n     * Actualiza los productos con los de la siguiente pagina.\n     */\n    updateProducts() {\n        if (!this._paginationService.getWaiting()) {\n            this._paginationService.getNext()\n        }\n    }\n    /**\n     * Devuelve el producto por codigo.\n     * @param code Codigo del producto\n     * @param variant Para indicar si es variante o no.\n     * @returns \n     */\n    getProductByCode(code: string, variant: boolean): Observable<Product> {\n        return this._connection.get(this.productByCodeApi(code, variant));\n    }\n\n    /**\n     * Recibe una lista de productos y retorna los mismos productos tantas veces como variantes tenga.\n     * cada producto retornado tendrá una única variante.\n     * @param products  Array. Lista de productos.\n     * @param withOption 'type' tipo de opción, code: código de la opción. 'defaultFirstOption': en caso de que no se pueda desdoblar por la opción indicada si el valor es verdadero se intentara desdoblar por la primera opción asociada al producto.\n     * 'checkIfStock': en caso de que esta valor sea verdadero se realiza un control de que la variantes cuenten con stock para ser un producto desdoblado por la variante, si el valor es falso no se realiza dicho control y el producto se desdoblara con stock en 0.\n     * @returns arreglo con los productos desdoblados por la opción solicitada.\n     * (opción por defecto que se intenta hacer el desdoblamiento 'color', o bien si en le parámetro withOption el atributo 'defaultFirstOption' es verdadero se desdobla por la primera opción asociada al producto)\n     */\n    getProductsWithUniqueVariant = (products: Product[], withOption: ParamsProductsWithUniqueVariant = { type: 'color', code: 'color', defaultFirstOption: false, checkIfStock: true }) => {\n\n        !withOption['code'] && withOption['type'] && (withOption['code'] = withOption['type']) || !withOption['code'] && (withOption['code'] = 'color')\n        !withOption['type'] && withOption['code'] && (withOption['type'] = withOption['code']) || !withOption['type'] && (withOption['type'] = 'color')\n        !withOption.hasOwnProperty('defaultFirstOption') && (withOption['defaultFirstOption'] = false)\n        !withOption.hasOwnProperty('checkIfStock') && (withOption['checkIfStock'] = true)\n\n        let productsUniqueVariant: any[] = [];\n        products.forEach((product: any) => {\n            let variants = [...product?.variants];\n            let option = product.options.find((opt: any) => opt.type.toLowerCase() === withOption.type?.toLowerCase());\n            if (option) {\n                option.values.forEach((optionValue: any) => {\n                    let modified_product = JSON.parse(JSON.stringify(product));\n                    modified_product.options.find((option: any) => option.type.toLowerCase() == withOption.type?.toLowerCase()).values = [{ code: optionValue.code, name: optionValue.name }];\n                    //busco una variante con ese code para asignarle la lista de imagenes\n                    let variantAux = variants.find(\n                        variant => ((withOption.checkIfStock && variant.stock > 0) || withOption.checkIfStock == false)\n                            && variant.options.length\n                            && variant.options.some((op: any) => (op.hasOwnProperty(withOption.code?.toLowerCase()) || op.hasOwnProperty(withOption.code?.toUpperCase()))\n                                && (op[`${withOption.code?.toLowerCase()}`] || op[`${withOption.code?.toUpperCase()}`]) === optionValue.code)\n\n                    );\n                    //console.log(\"---\",variantAux);\n                    variantAux && productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue));\n                })\n            } else {\n                /**\n                 * se modifica el caso para cuando se toma el primer `option` del producto para\n                 * armar la lista de productos con variantes.\n                 */\n                if (withOption.defaultFirstOption && product.options?.length) {\n                    let firstOptions = product.options[0]\n                    product.options[0].values.forEach((optionValue: any) => {\n\n                        let modified_product = JSON.parse(JSON.stringify(product));\n                        modified_product.options.find((option: Options) => option.type == firstOptions.type).values = [{ code: optionValue.code, name: optionValue.name }];\n\n                        let variantAux = variants.find(variant => {\n                            return variant.options.find((elem: any) => elem[firstOptions.code] == optionValue.code)\n                        })\n\n                        if (variantAux && variantAux.images.length == 0) {\n                            variantAux.images = product.picturesdefault\n                        }\n\n                        if (withOption.checkIfStock) {\n                            (variantAux && variantAux.stock > 0) ? productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue)) : null;\n                        } else {\n                            variantAux && productsUniqueVariant.push(this.productWithVariantValues(modified_product, variantAux, optionValue))\n                        }\n\n                    })\n                } else {\n                    productsUniqueVariant.push(product)\n                }\n\n            }\n        })\n        return productsUniqueVariant.length > 0 ? productsUniqueVariant : products;\n    }\n\n    productWithVariantValues = (product: Product, variant: any, optionValue: any) => {\n        product.picturesdefault = [...variant.images]\n        product.variant_id = variant.code; //lo dejo aca hasta asegurarnos de que no se estaba usando en otra parte.\n        product.stock = variant.stock || 0; //lo dejo aca hasta asegurarnos de que no se estaba usando en otra parte.\n        product.price = variant.price.toString() || '0';\n        product.currentOption = {\n            ...optionValue,\n            productCode: product.id,\n            variantCode: variant.code,\n            stock: variant.stock || 0,\n            finalPrice: variant.saleprice || variant.price || 0,\n        }\n        return product\n    }\n\n    private getObjectWithVariant = (): ParamsProductsWithUniqueVariant => {\n        return this._consts.getParamsProductsWithUniqueVariant()\n    }\n}\n"]}

package/esm2022/lib/ec-services/re-captcha.service.mjs

@@ -0,0 +1,114 @@
+import { afterNextRender, inject, Injectable } from '@angular/core';
+import { BehaviorSubject, concatMap, firstValueFrom, map } from 'rxjs';
+import { ConnectionService } from '../api';
+import { ParametersService } from './parameters.service';
+import { ApiConstantsService } from '../constants';
+import * as i0 from "@angular/core";
+export class ReCaptchaService {
+    _connection = inject(ConnectionService);
+    _paramsService = inject(ParametersService);
+    _apiConsts = inject(ApiConstantsService);
+    _recaptchaSubject = new BehaviorSubject({ siteKey: '' });
+    recaptcha$ = this._recaptchaSubject.asObservable();
+    params$ = this._paramsService.getParameters();
+    params;
+    urlBaseFormat = '';
+    testing = "easycommercetech";
+    productionEnvironment = false;
+    recaptchaSiteKeysUrl = './assets/recaptcha/recaptcha-site-keys.json';
+    recaptchaSitesUrl = './assets/recaptcha/recaptcha-sites.json';
+    recaptchaSitesUrlProd = './assets/recaptcha/recaptcha-sites-prod.json';
+    RECAPTCHA_SITE_KEYS = [];
+    RECAPTCHA_SITES = [];
+    constructor() {
+        this.params$.subscribe(params => this.params = params);
+        this.initializer();
+        afterNextRender(() => {
+            this.urlBaseFormat = this.formatUrl(location.href);
+            this.productionEnvironment = this.isProd();
+        });
+    }
+    /**
+     * Devuelve true si la url es de produccion, false en caso contrario.
+     * @returns {Boolean}
+     */
+    isProd() {
+        return !this.urlBaseFormat.includes(this.testing);
+    }
+    /**
+     * Recibe una url y se encarga de quitarle "http", "/" y las demas rutas, para devolver la url
+     * del sitio con una formato limpio. Ejemplo "https://ejemplo.com.ar/ruta1/ruta2/" a "ejemplo.com.ar"
+     * @param {string} url url que sera formateada
+     * @returns {string} url formateada
+     */
+    formatUrl(url) {
+        return url.split("/").filter(e => e != "/").filter(e => !e.includes("http")).filter(e => e.length).slice(0, 1).pop() || '';
+    }
+    /**
+     * Path que contiene la direccion del endpoint referido al captcha
+     * @returns {string}
+     */
+    captchaApi() { return `${this._apiConsts.SHOP_API_URL}channels`; }
+    /**
+     * Prioriza si existe un parametro desde el backend de nombre 'recaptcha_key_canal',
+     * de no existir este busca uno de tipo general de nombre 'recaptcha_key',
+     * y en caso de que este no exista se realiza lo siguiente:
+     * carga las variables RECAPTCHA_SITES y RECAPTCHA_SITE_KEYS, con los valores
+     * de los Json estaticos, para posteriormente obtener la "siteKey"(clave del captcha) en caso
+     * de que no venga desde el backend.
+     */
+    initializer() {
+        let paramThisChannel = this.params.find((param) => param.code === `recaptcha_key_${this._apiConsts.CHANNEL}`);
+        if (paramThisChannel) {
+            this._recaptchaSubject.next({ siteKey: paramThisChannel.value });
+        }
+        else {
+            let paramGeneral = this.params.find((param) => param.code === 'recaptcha_key');
+            if (paramGeneral) {
+                this._recaptchaSubject.next({ siteKey: paramGeneral.value });
+            }
+            else {
+                this.getRecaptchaSites().pipe(map((res) => this.RECAPTCHA_SITES = res), concatMap(res => this.getRecaptchaSiteKeys().pipe(map(res => this.RECAPTCHA_SITE_KEYS = res)))).subscribe(e => this.getSiteKey());
+            }
+        }
+    }
+    /**
+     * Obtiene los datos del archivo .json en donde se guardan las claves.
+     * @returns {Observable<any>} Datos obtenidos del archivo con las claves captcha
+     */
+    getRecaptchaSiteKeys() {
+        return this._connection.getWithFullUrl(this.recaptchaSiteKeysUrl);
+    }
+    /**
+     * Se obtiene los datos segun el entorno en que se ejecute
+     * @returns {Observable<any>} Datos obtenidos del archivo con las url de los sitios
+     */
+    getRecaptchaSites() {
+        return this.productionEnvironment ?
+            this._connection.getWithFullUrl(this.recaptchaSitesUrlProd) :
+            this._connection.getWithFullUrl(this.recaptchaSitesUrl);
+    }
+    /**
+     * Genera una peticion para recibir la clave del recaptcha. En caso de no tener exito,
+     * utiliza los archivos estaticos para retornar una clave por defecto. Rellena el Observable con
+     * los datos generados.
+     */
+    getSiteKey() {
+        firstValueFrom(this._connection.get(this.captchaApi())).then((res) => {
+            this._recaptchaSubject.next({
+                siteKey: res.siteKey ? res.siteKey : this.RECAPTCHA_SITE_KEYS[this.RECAPTCHA_SITES[this.urlBaseFormat]]
+            });
+        }, (err) => {
+            this._recaptchaSubject.next({ siteKey: this.RECAPTCHA_SITE_KEYS[this.RECAPTCHA_SITES[this.urlBaseFormat]] });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ReCaptchaService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ReCaptchaService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ReCaptchaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"re-captcha.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/re-captcha.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { afterNextRender, inject, Injectable } from '@angular/core';\nimport { RecaptchaSettings } from 'ng-recaptcha-2';\nimport { BehaviorSubject, concatMap, firstValueFrom, map, Observable } from 'rxjs';\nimport { ConnectionService } from '../api';\nimport { ParametersService } from './parameters.service';\nimport { ApiConstantsService } from '../constants';\n\n@Injectable({\n\tprovidedIn: 'root'\n})\nexport class ReCaptchaService {\n\n\tprivate _connection: ConnectionService = inject(ConnectionService);\n\tprivate _paramsService: ParametersService = inject(ParametersService);\n\tprivate _apiConsts: ApiConstantsService = inject(ApiConstantsService);\n\n\tprivate _recaptchaSubject: BehaviorSubject<RecaptchaSettings> = new BehaviorSubject<RecaptchaSettings>({ siteKey: '' });\n\tpublic recaptcha$ = this._recaptchaSubject.asObservable();\n\n\tprivate params$ = this._paramsService.getParameters();\n\tpublic params: any;\n\n\tprivate urlBaseFormat: string = '';\n\tprivate testing: string = \"easycommercetech\"\n\tprivate productionEnvironment: Boolean = false;\n\n\tprivate recaptchaSiteKeysUrl = './assets/recaptcha/recaptcha-site-keys.json';\n\tprivate recaptchaSitesUrl = './assets/recaptcha/recaptcha-sites.json';\n\tprivate recaptchaSitesUrlProd = './assets/recaptcha/recaptcha-sites-prod.json'\n\n\tprivate RECAPTCHA_SITE_KEYS: any = []\n\tprivate RECAPTCHA_SITES: any = []\n\n\tconstructor() {\n\t\tthis.params$.subscribe(params => this.params = params);\t\n\t\tthis.initializer();\n\t\tafterNextRender(()=> {\n\t\t\tthis.urlBaseFormat = this.formatUrl(location.href);\n\t\t\tthis.productionEnvironment = this.isProd();\n\t\t})\n\t}\n\t/**\n     * Devuelve true si la url es de produccion, false en caso contrario. \n     * @returns {Boolean}\n     */\n\tprivate isProd(): Boolean {\n\t\treturn !this.urlBaseFormat.includes(this.testing)\n\t}\n\t/**\n     * Recibe una url y se encarga de quitarle \"http\", \"/\" y las demas rutas, para devolver la url\n     * del sitio con una formato limpio. Ejemplo \"https://ejemplo.com.ar/ruta1/ruta2/\" a \"ejemplo.com.ar\" \n     * @param {string} url url que sera formateada \n     * @returns {string} url formateada\n     */\n\tprivate formatUrl(url: string): string {\n\t\treturn url.split(\"/\").filter(e => e != \"/\").filter(e => !e.includes(\"http\")).filter(e => e.length).slice(0,1).pop() || ''\n\t}\n\n\t/**\n     * Path que contiene la direccion del endpoint referido al captcha\n     * @returns {string} \n     */\n    private captchaApi():string { return `${this._apiConsts.SHOP_API_URL}channels`;}\n\t/**\n     * Prioriza si existe un parametro desde el backend de nombre 'recaptcha_key_canal', \n     * de no existir este busca uno de tipo general de nombre 'recaptcha_key',\n     * y en caso de que este no exista se realiza lo siguiente: \n     * carga las variables RECAPTCHA_SITES y RECAPTCHA_SITE_KEYS, con los valores\n     * de los Json estaticos, para posteriormente obtener la \"siteKey\"(clave del captcha) en caso\n     * de que no venga desde el backend. \n     */\n\tprivate initializer(): void {\n\t\tlet paramThisChannel = this.params.find((param:any) => param.code === `recaptcha_key_${this._apiConsts.CHANNEL}`)\n\t\tif(paramThisChannel){\n\t\t\tthis._recaptchaSubject.next({siteKey: paramThisChannel.value});\n\t\t}else{\n\t\t\tlet paramGeneral = this.params.find((param:any) => param.code === 'recaptcha_key')\n\t\t\tif(paramGeneral){\n\t\t\t\tthis._recaptchaSubject.next({siteKey: paramGeneral.value});\n\t\t\t} else {\n\t\t\t\tthis.getRecaptchaSites().pipe(\n\t\t\t\t\tmap((res:any) => this.RECAPTCHA_SITES = res),\n\t\t\t\t\tconcatMap( res => this.getRecaptchaSiteKeys().pipe(\n\t\t\t\t\t\tmap(res=> this.RECAPTCHA_SITE_KEYS = res)\n\t\t\t\t\t))\n\t\t\t\t).subscribe(\n\t\t\t\t\te => this.getSiteKey()\n\t\t\t\t)\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n     * Obtiene los datos del archivo .json en donde se guardan las claves.\n     * @returns {Observable<any>} Datos obtenidos del archivo con las claves captcha\n     */\n\tprivate getRecaptchaSiteKeys(): Observable<any>{\n\t\treturn this._connection.getWithFullUrl(this.recaptchaSiteKeysUrl)\n\t}\n\t/**\n     * Se obtiene los datos segun el entorno en que se ejecute\n     * @returns {Observable<any>} Datos obtenidos del archivo con las url de los sitios\n     */\n\tprivate getRecaptchaSites(): Observable<any>{\n\t\treturn this.productionEnvironment ? \n\t\t\tthis._connection.getWithFullUrl(this.recaptchaSitesUrlProd) :\n\t\t\tthis._connection.getWithFullUrl(this.recaptchaSitesUrl);\n\t}\n\t/**\n     * Genera una peticion para recibir la clave del recaptcha. En caso de no tener exito,\n     * utiliza los archivos estaticos para retornar una clave por defecto. Rellena el Observable con\n     * los datos generados.\n     */\n\tprivate getSiteKey(){\n\t\tfirstValueFrom(this._connection.get(this.captchaApi())).then(\n\t\t\t(res: any) => {\n\t\t\t\tthis._recaptchaSubject.next( {\n\t\t\t\t\tsiteKey: res.siteKey ? res.siteKey : this.RECAPTCHA_SITE_KEYS[this.RECAPTCHA_SITES[this.urlBaseFormat]]\n\t\t\t\t})\n\t\t\t},\n\t\t\t(err: any) => {\n\t\t\t\tthis._recaptchaSubject.next({ siteKey: this.RECAPTCHA_SITE_KEYS[this.RECAPTCHA_SITES[this.urlBaseFormat]]})\n\t\t\t}\n\t\t)\n\t}\n}\n"]}

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

@@ -0,0 +1,158 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { CheckoutService } from './checkout.service';
+import { ConnectionService } from '../api';
+import { ApiConstantsService } from '../constants';
+import { CartService } from './cart.service';
+import { StoresService } from './stores.service';
+import { AnalyticsService } from './analytics';
+import * as i0 from "@angular/core";
+export class ShipmentService {
+    _checkoutService = inject(CheckoutService);
+    _connection = inject(ConnectionService);
+    _apiConsts = inject(ApiConstantsService);
+    _cartService = inject(CartService);
+    _storesService = inject(StoresService);
+    _analyticsService = inject(AnalyticsService);
+    _methodsSubject = new BehaviorSubject([]);
+    _costsSubject = new BehaviorSubject([]);
+    _stateSubject = new BehaviorSubject({ doing: false, ok: false, data: null });
+    methods$ = this._methodsSubject.asObservable();
+    costs$ = this._costsSubject.asObservable();
+    state$ = this._stateSubject.asObservable();
+    buttonsDisabled = false;
+    order;
+    _subscription = null;
+    //API URL
+    baseApi() { return 'shop-api/' + this._apiConsts.CHANNEL + '/' + 'checkout/' + this._cartService.getCartToken(); }
+    shipmentMethodsApi() { return this.baseApi() + '/shipping'; }
+    ;
+    putShipmentApi() { return this.baseApi() + '/shipping/' + this._stateSubject.getValue().data.method; }
+    ;
+    putContractApi = () => 'shop-api/' + this._apiConsts.CHANNEL + '/checkout/' + this._cartService.getCartToken() + '/shipping-contract';
+    calculatedCostsApi = () => 'shop-api/' + this._apiConsts.CHANNEL + '/carts/' + this._cartService.getCartToken() + '/multiple-estimated-shipping-cost';
+    constructor() { }
+    setMethod(method) {
+        // Deshabilitar todos los botones
+        //this.buttonsDisabled = true;
+        this._costsSubject.next([]);
+        this._stateSubject.next({ doing: true, ok: false, data: { method } });
+        return this.putShipment().then((res) => {
+            this._checkoutService.updateAsociatedData(res);
+            this.order = res;
+            return this.getCalculatedCosts();
+        }).then((res) => {
+            this.modifyCostsResponse(res, this.getUserData().shippingAddress.postcode, method);
+            return { success: true, order: this.order };
+        }).then((res) => {
+            const firstContract = this._costsSubject.getValue();
+            this.setContract(firstContract);
+            return { success: true, order: this.order };
+        }).catch((error) => {
+            console.log(error);
+            return { success: false, error: error };
+        });
+    }
+    putShipment() {
+        return firstValueFrom(this._connection.put(this.putShipmentApi(), { method: this._stateSubject.getValue().data.method }));
+    }
+    getCalculatedCosts() { return firstValueFrom(this._connection.get(this.calculatedCostsApi())); }
+    ;
+    getShipmentMethods = () => {
+        firstValueFrom(this._connection.getErrorNotHandler(this.shipmentMethodsApi())).then(res => {
+            this._methodsSubject.next(this.responseToList(res));
+        }, err => {
+            this._methodsSubject.next([]);
+        }).catch(err => {
+            this._methodsSubject.next([]);
+        });
+    };
+    responseToList(response) {
+        return (response.shipments && response.shipments.length > 0) && Object.keys(response.shipments[0].methods).map(key => response.shipments[0].methods[key]);
+    }
+    restartStep() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+    * Obtener información obtenida en el paso de datos asociados al usuario y a la facturación
+    */
+    getUserData = () => this._checkoutService.getStepData('address');
+    // UTILS
+    /**
+     * @param response De api de solicitud de costos por metodo de envío seleccionado
+     * @param post_code Indicado en el paso de Addressing (datos personales y de facturación)
+     * @param method Metodo de envío seleccionado
+     */
+    modifyCostsResponse(response, post_code, method) {
+        response = response.multiplePrices;
+        let branch_delivery = response.findIndex((submethod) => submethod.name == 'branch_delivery');
+        if (branch_delivery != -1) {
+            response[branch_delivery].contracts = response[branch_delivery].contracts.map((contract) => {
+                let branch_property = contract.branch_property || {};
+                let address_data = branch_property.address || {};
+                return {
+                    contract: 'branch_delivery',
+                    name: contract.name,
+                    price: contract.price,
+                    ...address_data,
+                    ...branch_property,
+                    computed: (address_data.street || '') + ' N° ' + (address_data.number || '')
+                };
+            });
+            this._costsSubject.next(response);
+        }
+        if (method.includes('pickup_store')) {
+            let final_method_data = response;
+            this._subscription = this._storesService.stores.subscribe((stores) => {
+                if (stores.length) {
+                    final_method_data.forEach((pickup_store) => {
+                        pickup_store.contracts.forEach((contract) => {
+                            const current_store = stores.find((store) => store.code == contract.name);
+                            if (!current_store)
+                                contract.detail = 'Sin información';
+                            else
+                                contract.detail = current_store.name + ' - ' + current_store.address;
+                            return contract;
+                        });
+                    });
+                    this._costsSubject.next(final_method_data);
+                }
+            });
+        }
+        else {
+            this._costsSubject.next(response);
+        }
+    }
+    ngOnDestroy() {
+        this._subscription && this._subscription.unsubscribe();
+    }
+    setContract(contract) {
+        const data = { ...contract, ...this.additionalParamsForContract(contract) };
+        return firstValueFrom(this._connection.put(this.putContractApi(), data)).then(order => {
+            this._analyticsService.callEvent('shipping_info', order);
+            this._checkoutService.updateAsociatedData(order);
+            return this._checkoutService.setStepData('shipment', order);
+        }, err => {
+            return new Promise((resolve, reject) => reject(new Error(err.error)));
+        }).catch(err => console.error(err));
+    }
+    additionalParamsForContract(contract) {
+        return {
+            shipping_method_contract: contract.shipping_method_contract
+                ? contract.shipping_method_contract
+                : contract.contract + '_' + contract.name,
+            shipping_method_branch_code: contract.shipping_method_branch_code
+                ? contract.shipping_method_branch_code
+                : (contract.contract && contract.contract == "branch_delivery") ? contract.number : contract.name
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ShipmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ShipmentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ShipmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shipment.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/shipment.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { BehaviorSubject, firstValueFrom, Observable, Subscription } from 'rxjs';\nimport { CheckoutService } from './checkout.service';\nimport { CheckoutProcessState } from '../interfaces';\nimport { ConnectionService } from '../api';\nimport { ApiConstantsService } from '../constants';\nimport { CartService } from './cart.service';\nimport { StoresService } from './stores.service';\nimport { AnalyticsService } from './analytics';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class ShipmentService {\n    private _checkoutService: CheckoutService = inject(CheckoutService);\n    private _connection: ConnectionService = inject(ConnectionService);\n    private _apiConsts: ApiConstantsService = inject(ApiConstantsService);\n    private _cartService: CartService = inject(CartService);\n    private _storesService: StoresService = inject(StoresService);\n    private _analyticsService: AnalyticsService = inject(AnalyticsService);\n\n    private _methodsSubject = new BehaviorSubject<any>([]);\n    private _costsSubject = new BehaviorSubject<any>([]);\n    private _stateSubject = new BehaviorSubject<CheckoutProcessState>({ doing: false, ok: false, data: null });\n\n    public methods$: Observable<any> = this._methodsSubject.asObservable();\n    public costs$: Observable<any[]> = this._costsSubject.asObservable();\n    public state$: Observable<any> = this._stateSubject.asObservable();\n    public buttonsDisabled: boolean = false;\n    public order: any;\n    private _subscription: Subscription | null = null;\n\n    //API URL\n    private baseApi() { return 'shop-api/' + this._apiConsts.CHANNEL + '/' + 'checkout/' + this._cartService.getCartToken(); }\n\n    public shipmentMethodsApi() { return this.baseApi() + '/shipping' };\n    public putShipmentApi() { return this.baseApi() + '/shipping/' + this._stateSubject.getValue().data.method };\n    public putContractApi = () => 'shop-api/' + this._apiConsts.CHANNEL + '/checkout/' + this._cartService.getCartToken() + '/shipping-contract';\n    public calculatedCostsApi = () => 'shop-api/' + this._apiConsts.CHANNEL + '/carts/' + this._cartService.getCartToken() + '/multiple-estimated-shipping-cost';\n\n\n    constructor() { }\n\n    setMethod(method: any): Promise<any> {\n        // Deshabilitar todos los botones\n        //this.buttonsDisabled = true;\n\n        this._costsSubject.next([]);\n        this._stateSubject.next({ doing: true, ok: false, data: { method } });\n\n        return this.putShipment().then(\n            (res: any) => {\n                this._checkoutService.updateAsociatedData(res);\n                this.order = res;\n                return this.getCalculatedCosts()\n            }).then(\n                (res: any) => {\n                    this.modifyCostsResponse(res, this.getUserData().shippingAddress.postcode, method)\n                    return { success: true, order: this.order };\n                }).then(\n                    (res:any) => {\n                        const firstContract = this._costsSubject.getValue();\n                        this.setContract(firstContract);\n                        return { success: true, order: this.order };\n                    }\n                ).catch((error) => {\n                    console.log(error)\n                    return { success: false, error: error };\n                })\n    }\n\n    private putShipment() {\n        return firstValueFrom(this._connection.put(this.putShipmentApi(), { method: this._stateSubject.getValue().data.method }));\n    }\n\n    getCalculatedCosts() { return firstValueFrom(this._connection.get(this.calculatedCostsApi())) };\n\n    getShipmentMethods = () => {\n        firstValueFrom(this._connection.getErrorNotHandler(this.shipmentMethodsApi())).then(\n            res => {\n                this._methodsSubject.next(this.responseToList(res))\n            },\n            err => {\n                this._methodsSubject.next([])\n            }\n        ).catch(err => {\n            this._methodsSubject.next([])\n        })\n    }\n    responseToList(response: any) {\n        return (response.shipments && response.shipments.length > 0) && Object.keys(response.shipments[0].methods).map(key => response.shipments[0].methods[key]);\n    }\n\n    restartStep() {\n        throw new Error('Method not implemented.');\n    }\n    /**\n    * Obtener información obtenida en el paso de datos asociados al usuario y a la facturación\n    */\n    getUserData = () => this._checkoutService.getStepData('address');\n    // UTILS\n\n    /**\n     * @param response De api de solicitud de costos por metodo de envío seleccionado\n     * @param post_code Indicado en el paso de Addressing (datos personales y de facturación)\n     * @param method Metodo de envío seleccionado\n     */\n    modifyCostsResponse(response: any, post_code: any, method: any) {\n        response = response.multiplePrices;\n        let branch_delivery = response.findIndex((submethod: any) => submethod.name == 'branch_delivery');\n        if (branch_delivery != -1) {\n            response[branch_delivery].contracts = response[branch_delivery].contracts.map(\n                (contract: any) => {\n                    let branch_property = contract.branch_property || {};\n                    let address_data = branch_property.address || {};\n                    return {\n                        contract: 'branch_delivery',\n                        name: contract.name,\n                        price: contract.price,\n                        ...address_data,\n                        ...branch_property,\n                        computed: (address_data.street || '') + ' N° ' + (address_data.number || '')\n                    };\n                });\n            this._costsSubject.next(response);\n        }\n        if (method.includes('pickup_store')) {\n            let final_method_data = response;\n            this._subscription = this._storesService.stores.subscribe((stores: any) => {\n                if (stores.length) {\n                    final_method_data.forEach((pickup_store: any) => {\n                        pickup_store.contracts.forEach((contract: any) => {\n                            const current_store = stores.find((store: any) => store.code == contract.name);\n                            if (!current_store) contract.detail = 'Sin información';\n                            else contract.detail = current_store.name + ' - ' + current_store.address;\n                            return contract;\n                        })\n                    })\n                    this._costsSubject.next(final_method_data);\n                }\n            })\n        } else {\n            this._costsSubject.next(response);\n        }\n    }\n\n    ngOnDestroy() {\n        this._subscription && this._subscription.unsubscribe();\n    }\n\n    setContract(contract: any){\n        const data = { ...contract, ...this.additionalParamsForContract(contract) };\n        return firstValueFrom(this._connection.put(this.putContractApi(), data)).then(\n            order => {\n                this._analyticsService.callEvent('shipping_info', order);\n                this._checkoutService.updateAsociatedData(order);\n                return  this._checkoutService.setStepData('shipment',order);},\n            err => {\n                return new Promise((resolve, reject) => reject(new Error(err.error)))\n            }\n        ).catch(err => console.error(err))\n    }\n    additionalParamsForContract(contract:any){\n        return {\n            shipping_method_contract:\n                contract.shipping_method_contract\n                    ? contract.shipping_method_contract\n                    : contract.contract + '_' + contract.name,\n            shipping_method_branch_code:\n                contract.shipping_method_branch_code\n                    ? contract.shipping_method_branch_code\n                    : (contract.contract && contract.contract == \"branch_delivery\") ? contract.number : contract.name\n        }\n    }\n}\n"]}

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

@@ -0,0 +1,27 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { ApiConstantsService } from '../constants';
+import { ConnectionService } from '../api';
+import * as i0 from "@angular/core";
+export class StoresService {
+    _apiConsts = inject(ApiConstantsService);
+    _connection = inject(ConnectionService);
+    _storesSubject = new BehaviorSubject([]);
+    stores = this._storesSubject.asObservable();
+    getAllStoresApi = () => 'shop-api/' + this._apiConsts.CHANNEL + '/stores';
+    constructor() {
+        firstValueFrom(this._connection.get(this.getAllStoresApi())).then(res => {
+            res.length && this._storesSubject.next(res);
+            !res.length && this._storesSubject.next(null);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: StoresService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: StoresService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: StoresService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TestService {
+    constructor() {
+        console.log('hola');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: TestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: TestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: TestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctZWFzeWNvbW1lcmNlLXYxOC9zcmMvbGliL2VjLXNlcnZpY2VzL3Rlc3Quc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sV0FBVztJQUV0QjtRQUNFLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDckIsQ0FBQzt1R0FKUyxXQUFXOzJHQUFYLFdBQVcsY0FGVixNQUFNOzsyRkFFUCxXQUFXO2tCQUh2QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgVGVzdFNlcnZpY2Uge1xuXG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIGNvbnNvbGUubG9nKCdob2xhJyk7XG4gICB9XG59XG4iXX0=