ng-easycommerce-v18 0.0.1 → 0.0.3

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

@@ -0,0 +1,83 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { ConnectionService } from '../api';
+import { map, ReplaySubject, shareReplay } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Servicio para manejar los canales de la aplicación
+ * @class ChannelService
+ */
+export class ChannelService {
+    /**
+     * Constantes de la API
+     */
+    apiConsts = inject(ApiConstantsService);
+    /**
+     * Constantes del core
+     */
+    consts = inject(CoreConstantsService);
+    /**
+     * Maneja las peticiones a la API
+     */
+    connection = inject(ConnectionService);
+    /**
+     * Subject para manejar los cambios en los canales.
+     */
+    channelSubject = new ReplaySubject();
+    /**
+     * Observable de canales.
+     */
+    channel$ = this.channelSubject.asObservable();
+    /**
+     * Almacena el canal activo en la aplicación.
+     */
+    activeChannel;
+    /**
+     * Almacena el tipo de canal.
+     */
+    channelType;
+    //API URL
+    /**
+     * Devuelve la url para obtener los datos de un canal.
+     * @returns
+     */
+    channelApi() { return `${this.apiConsts.SHOP_API_URL}${this.apiConsts.CHANNEL}/channel`; }
+    constructor() { }
+    /**
+     * Obtiene el canal de la API
+     * @returns Observable con el canal.
+     */
+    getChannel = () => {
+        this.connection.get(this.channelApi()).pipe(shareReplay(1), map((response) => {
+            this.setChannelInfo(response);
+            this.channelSubject.next(response);
+            this.channelType = response.type;
+            return response;
+        })).subscribe();
+        return this.channel$;
+    };
+    /**
+     * Cambia la configuración del canal con un canal nuevo.
+     * @param channelObj
+     */
+    setChannelInfo(channelObj) {
+        this.apiConsts.setChannel(channelObj.code);
+        this.consts.setCurrency(channelObj.baseCurrency);
+        this.activeChannel = channelObj;
+        //this.injector.get(AddressingService).setTypeSelectAddress(channelObj.headquarterSelectionOnly || 'LOAD_ADDRESS_AND_SELECTION')
+    }
+    /**
+     * Devuelve el canal activo en la aplicación.
+     * @returns
+     */
+    getActiveChannel() { return this.activeChannel; }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ChannelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ChannelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: ChannelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,180 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, combineLatest, firstValueFrom, ReplaySubject } from 'rxjs';
+import { CartService } from './cart.service';
+import { ConnectionService } from '../api';
+import { AnalyticsService } from './analytics';
+import { ApiConstantsService } from '../constants';
+import { Step, User } from '../classes';
+import { AuthService } from './auth.service';
+import { OrderUtilityService } from './order-utility.service';
+import { Router } from '@angular/router';
+import { ToastService } from './toast.service';
+import * as i0 from "@angular/core";
+export class CheckoutService {
+    _cartService = inject(CartService);
+    _connection = inject(ConnectionService);
+    _analyticsService = inject(AnalyticsService);
+    _consts = inject(ApiConstantsService);
+    _authService = inject(AuthService);
+    _orderUtilityService = inject(OrderUtilityService);
+    _router = inject(Router);
+    _toastService = inject(ToastService);
+    _canCheckoutSubject = new ReplaySubject();
+    _stateSubject = new BehaviorSubject([]);
+    _lastStepSubject = new BehaviorSubject(false);
+    _loadingSubject = new BehaviorSubject(false);
+    _orderSubject = new BehaviorSubject(null);
+    _associatedDataSubject = new BehaviorSubject(null);
+    _loadingStepSubject = new BehaviorSubject(false);
+    canCheckout$ = this._canCheckoutSubject.asObservable();
+    state$ = this._stateSubject.asObservable();
+    isLastStep$ = this._lastStepSubject.asObservable();
+    associatedData$ = this._associatedDataSubject.asObservable();
+    order$ = this._orderSubject.asObservable();
+    loadingStep$ = this._loadingStepSubject.asObservable();
+    total;
+    cartLocal;
+    checkoutData = {};
+    order;
+    //API Methods
+    baseApi = () => 'shop-api/' + this._consts.CHANNEL + '/checkout/' + this._cartService.getCartToken();
+    getHasPurchaseConditions() { return 'shop-api/' + this._consts.CHANNEL + '/carts/' + this._cartService.getCartToken() + '/has_purchase_conditions'; }
+    ;
+    completeApi() { return this.baseApi() + '/complete'; }
+    ;
+    constructor() {
+        combineLatest([this._cartService.cartItems$, this._cartService.loading$]).subscribe(([items, loading]) => {
+            if (!loading && items.length > 0) {
+                this._canCheckoutSubject.next(true);
+                this._cartService.getTotalAmount().subscribe((res) => {
+                    this.total = res;
+                });
+            }
+        });
+        this._cartService.cart$.subscribe(cart => cart && (this.cartLocal = cart) && this.updateAsociatedData(cart));
+        this.order$.subscribe(order => order && this.updateAsociatedData(order));
+    }
+    setSteps(steps) {
+        let final_steps = [];
+        steps.forEach((step, i) => final_steps.push(new Step(step.name, step.priority || (i + 1), step.label, step.state)));
+        this._stateSubject.next(final_steps);
+        if (final_steps.length == 1) {
+            this._lastStepSubject.next(true);
+        }
+        console.log(final_steps);
+        firstValueFrom(this._connection.get(this.getHasPurchaseConditions())).then(res => {
+            this._analyticsService.callEvent('checkout_init', { ...this.cartLocal, currency: this.cartLocal?.currency, value: this.cartLocal?.total });
+        });
+    }
+    next() {
+        this._loadingStepSubject.next(true);
+        const steps = this._stateSubject.getValue();
+        const readyStep = steps.findIndex(step => step.state === 'ready');
+        if (steps[readyStep + 1]) {
+            steps[readyStep].state = 'doing';
+            steps[readyStep + 1].state = 'ready';
+            if (!steps[readyStep + 2])
+                this._lastStepSubject.next(true);
+            this._loadingStepSubject.next(false);
+        }
+        else {
+            this.complete().then(res => {
+                if (res.ok) {
+                    this._router.navigate(['checkout/order_success']);
+                }
+                else {
+                    this._toastService.show('operation-error');
+                }
+                this._loadingStepSubject.next(false);
+            }, err => {
+                console.log(err);
+                this._loadingStepSubject.next(false);
+                this._toastService.show('operation-error');
+            });
+        }
+    }
+    back() {
+        const steps = this._stateSubject.getValue();
+        const readyStep = steps.findIndex(step => step.state === 'ready');
+        this._lastStepSubject.next(false);
+        if (steps[readyStep - 1]) {
+            steps[readyStep].state = 'pending';
+            steps[readyStep - 1].state = 'ready';
+        }
+    }
+    setOrder = (order) => { this.order = order, this._orderSubject.next(order); };
+    //getOrder = () => this.order || this.orderSubject.value;
+    completeOrder = () => firstValueFrom(this._connection.put(this.completeApi(), { email: this.checkoutData.email, notes: this.checkoutData.notes || '' }));
+    complete = async () => {
+        try {
+            this._loadingSubject.next(true);
+            let result = await this.completeOrder();
+            if (result && result.error) {
+                this._cartService.changeHaveToUpdate(false);
+                this._loadingSubject.next(false);
+                return ({ ok: false, require_login: true, message: 'not-completed' });
+            }
+            this.setOrder(result);
+            this._analyticsService.callEvent('purchase', { ...result, currency: result.currency, value: result.total });
+            this._cartService.clearAndResetCart();
+            this._canCheckoutSubject.next(false);
+            //this._onReadySubject.next(false);
+            this._loadingSubject.next(false);
+            return ({ ok: true, require_login: false, message: '' });
+        }
+        catch (error) {
+            this._loadingSubject.next(false);
+            console.error('Error in complete:', error);
+            return { ok: false, require_login: false, message: 'An error occurred' };
+        }
+    };
+    updateAsociatedData = (cart) => {
+        let result = this._orderUtilityService.getPromotions(cart);
+        const userProfile = User.fromJson(this._authService.getUserProfileAsUser());
+        if (result) {
+            if (userProfile.isWholesaler() && cart.totals.taxes != 0) {
+                let total = { ...result[result.length - 1] };
+                result[result.length - 1] = {
+                    type: 'taxes',
+                    name: 'taxes',
+                    amount: cart.totals.taxes
+                };
+                result.push(total);
+            }
+            let shipment = result?.find((promotion) => promotion.type == "shipment");
+            if (!shipment && cart.totals.shipping != 0) {
+                if (result?.length && !result.find((item) => item.type === "shipment")) {
+                    let total = { ...result[result.length - 1] };
+                    result[result.length - 1] = {
+                        type: 'shipment',
+                        name: 'shipment',
+                        amount: cart.totals.shipping
+                    };
+                    result.push(total);
+                }
+            }
+            this._associatedDataSubject.next(result);
+        }
+    };
+    getStepData = (step_name) => {
+        let step_result = this._stateSubject.getValue().find(step => step.name == step_name);
+        return (step_result && step_result.data);
+    };
+    setStepData = (step_name, data) => {
+        let step = this._stateSubject.getValue().find(step => step.name == step_name);
+        step?.ready(data);
+        /* if (data) {
+            this._orderSubject.next(data);
+            this.total = data.totals.total;
+        } */
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CheckoutService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CheckoutService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CheckoutService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/checkout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { BehaviorSubject, combineLatest, firstValueFrom, Observable, ReplaySubject } from 'rxjs';\r\nimport { CartService } from './cart.service';\r\nimport { CheckoutData, IStep, StepType } from '../interfaces';\r\nimport { ConnectionService } from '../api';\r\nimport { AnalyticsService } from './analytics';\r\nimport { ApiConstantsService } from '../constants';\r\nimport { Step, User } from '../classes';\r\nimport { AuthService } from './auth.service';\r\nimport { OrderUtilityService } from './order-utility.service';\r\nimport { Router } from '@angular/router';\r\nimport { ToastService } from './toast.service';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class CheckoutService {\r\n\r\n\tprivate _cartService: CartService = inject(CartService);\r\n\tprivate _connection: ConnectionService = inject(ConnectionService);\r\n\tprivate _analyticsService: AnalyticsService = inject(AnalyticsService);\r\n\tprivate _consts: ApiConstantsService = inject(ApiConstantsService);\r\n\tprivate _authService: AuthService = inject(AuthService);\r\n\tprivate _orderUtilityService: OrderUtilityService = inject(OrderUtilityService);\r\n\tprivate _router: Router = inject(Router);\r\n\tprivate _toastService: ToastService = inject(ToastService);\r\n\r\n\tprivate _canCheckoutSubject = new ReplaySubject<boolean>();\r\n\tprivate _stateSubject = new BehaviorSubject<Step[]>([])\r\n\tprivate _lastStepSubject = new BehaviorSubject<boolean>(false);\r\n\tprivate _loadingSubject = new BehaviorSubject<boolean>(false);\r\n\tprivate _orderSubject = new BehaviorSubject<any>(null);\r\n\tprivate _associatedDataSubject = new BehaviorSubject<CheckoutData[] | null>(null);\r\n\tprivate _loadingStepSubject = new BehaviorSubject<boolean>(false);\r\n\r\n\tpublic canCheckout$: Observable<boolean> = this._canCheckoutSubject.asObservable();\r\n\tpublic state$: Observable<any> = this._stateSubject.asObservable();\r\n\tpublic isLastStep$: Observable<boolean> = this._lastStepSubject.asObservable();\r\n\tpublic associatedData$: Observable<any> = this._associatedDataSubject.asObservable();\r\n\tpublic order$: Observable<any> = this._orderSubject.asObservable();\r\n\tpublic loadingStep$:Observable<boolean> = this._loadingStepSubject.asObservable();\r\n\r\n\tpublic total: any;\r\n\tprivate cartLocal: any;\r\n\tprivate checkoutData: any = {};\r\n\tprivate order: any;\r\n\r\n\t//API Methods\r\n\tbaseApi = () => 'shop-api/' + this._consts.CHANNEL + '/checkout/' + this._cartService.getCartToken();\r\n\tgetHasPurchaseConditions() { return 'shop-api/' + this._consts.CHANNEL + '/carts/' + this._cartService.getCartToken() + '/has_purchase_conditions' };\r\n\tcompleteApi() { return this.baseApi() + '/complete' };\r\n\r\n\r\n\tconstructor() {\r\n\t\tcombineLatest([this._cartService.cartItems$, this._cartService.loading$]).subscribe(([items, loading]) => {\r\n\t\t\tif (!loading && items.length > 0) {\r\n\t\t\t\tthis._canCheckoutSubject.next(true);\r\n\t\t\t\tthis._cartService.getTotalAmount().subscribe((res: any) => {\r\n\t\t\t\t\tthis.total = res;\r\n\t\t\t\t})\r\n\t\t\t}\r\n\t\t})\r\n\t\tthis._cartService.cart$.subscribe(cart => cart && (this.cartLocal = cart) && this.updateAsociatedData(cart));\r\n\t\tthis.order$.subscribe(order => order && this.updateAsociatedData(order))\r\n\t}\r\n\r\n\tsetSteps(steps: IStep[]) {\r\n\t\tlet final_steps: Step[] = [];\r\n\t\tsteps.forEach((step, i) => final_steps.push(new Step(step.name, step.priority || (i + 1), step.label, step.state)));\r\n\t\tthis._stateSubject.next(final_steps);\r\n\t\tif (final_steps.length == 1) {\r\n\t\t\tthis._lastStepSubject.next(true);\r\n\t\t}\r\n\t\tconsole.log(final_steps);\r\n\t\tfirstValueFrom(this._connection.get(this.getHasPurchaseConditions())).then(\r\n\t\t\tres => {\r\n\t\t\t\tthis._analyticsService.callEvent('checkout_init', { ...this.cartLocal, currency: this.cartLocal?.currency, value: this.cartLocal?.total })\r\n\t\t\t}\r\n\t\t)\r\n\t}\r\n\r\n\tnext() {\r\n\t\tthis._loadingStepSubject.next(true);\r\n\t\tconst steps = this._stateSubject.getValue()\r\n\t\tconst readyStep = steps.findIndex(step => step.state === 'ready');\r\n\t\tif (steps[readyStep + 1]) {\r\n\t\t\tsteps[readyStep].state = 'doing'\r\n\t\t\tsteps[readyStep + 1].state = 'ready';\r\n\t\t\tif (!steps[readyStep + 2]) this._lastStepSubject.next(true);\r\n\t\t\tthis._loadingStepSubject.next(false)\r\n\t\t} else {\r\n\t\t\tthis.complete().then(\r\n\t\t\t\tres => {\r\n\t\t\t\t\tif (res.ok) {\r\n\t\t\t\t\t\tthis._router.navigate(['checkout/order_success'])\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tthis._toastService.show('operation-error')\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis._loadingStepSubject.next(false)\r\n\t\t\t\t},\r\n\t\t\t\terr => {\r\n\t\t\t\t\tconsole.log(err)\r\n\t\t\t\t\tthis._loadingStepSubject.next(false)\r\n\t\t\t\t\tthis._toastService.show('operation-error')\r\n\t\t\t\t}\r\n\t\t\t)\r\n\t\t}\r\n\t}\r\n\r\n\tback() {\r\n\t\tconst steps = this._stateSubject.getValue()\r\n\t\tconst readyStep = steps.findIndex(step => step.state === 'ready');\r\n\t\tthis._lastStepSubject.next(false);\r\n\t\tif (steps[readyStep - 1]) {\r\n\t\t\tsteps[readyStep].state = 'pending'\r\n\t\t\tsteps[readyStep - 1].state = 'ready';\r\n\t\t}\r\n\t}\r\n\r\n\tsetOrder = (order: any) => { this.order = order, this._orderSubject.next(order) };\r\n\t//getOrder = () => this.order || this.orderSubject.value;\r\n\r\n\tprivate completeOrder = () => firstValueFrom(this._connection.put(this.completeApi(), { email: this.checkoutData.email, notes: this.checkoutData.notes || '' }));\r\n\r\n\tcomplete = async () => {\r\n\t\ttry {\r\n\t\t\tthis._loadingSubject.next(true);\r\n\t\t\tlet result = await this.completeOrder();\r\n\t\t\t\r\n\t\t\tif (result && result.error) {\r\n\t\t\t\tthis._cartService.changeHaveToUpdate(false);\r\n\t\t\t\tthis._loadingSubject.next(false);\r\n\t\t\t\treturn ({ ok: false, require_login: true, message: 'not-completed' });\r\n\t\t\t}\r\n\r\n\t\t\tthis.setOrder(result);\r\n\t\t\tthis._analyticsService.callEvent('purchase', { ...result, currency: result.currency, value: result.total });\r\n\t\t\tthis._cartService.clearAndResetCart();\r\n\t\t\tthis._canCheckoutSubject.next(false);\r\n\t\t\t//this._onReadySubject.next(false);\r\n\t\t\tthis._loadingSubject.next(false);\r\n\r\n\t\t\treturn ({ ok: true, require_login: false, message: '' });\r\n\t\t} catch (error) {\r\n\t\t\tthis._loadingSubject.next(false);\r\n\t\t\tconsole.error('Error in complete:', error);\r\n\r\n\t\t\treturn { ok: false, require_login: false, message: 'An error occurred' };\r\n\t\t}\r\n\r\n\t}\r\n\r\n\tupdateAsociatedData = (cart: any) => {\r\n\t\tlet result = this._orderUtilityService.getPromotions(cart);\r\n\t\tconst userProfile: User = User.fromJson(this._authService.getUserProfileAsUser());\r\n\t\tif (result) {\r\n\t\t\tif (userProfile.isWholesaler() && cart.totals.taxes != 0) {\r\n\t\t\t\tlet total = { ...result[result.length - 1] };\r\n\t\t\t\tresult[result.length - 1] = {\r\n\t\t\t\t\ttype: 'taxes',\r\n\t\t\t\t\tname: 'taxes',\r\n\t\t\t\t\tamount: cart.totals.taxes\r\n\t\t\t\t}\r\n\t\t\t\tresult.push(total);\r\n\t\t\t}\r\n\t\t\tlet shipment = result?.find((promotion: any) => promotion.type == \"shipment\");\r\n\t\t\tif (!shipment && cart.totals.shipping != 0) {\r\n\r\n\t\t\t\tif (result?.length && !result.find((item: any) => item.type === \"shipment\")) {\r\n\t\t\t\t\tlet total = { ...result[result.length - 1] };\r\n\t\t\t\t\tresult[result.length - 1] = {\r\n\t\t\t\t\t\ttype: 'shipment',\r\n\t\t\t\t\t\tname: 'shipment',\r\n\t\t\t\t\t\tamount: cart.totals.shipping\r\n\t\t\t\t\t}\r\n\t\t\t\t\tresult.push(total);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tthis._associatedDataSubject.next(result);\r\n\t\t}\r\n\t}\r\n\r\n\tgetStepData = (step_name: StepType) => {\r\n\t\tlet step_result = this._stateSubject.getValue().find(step => step.name == step_name);\r\n\t\treturn (step_result && step_result.data);\r\n\t}\r\n\r\n\tsetStepData = (step_name: StepType, data: any) => {\r\n\t\tlet step = this._stateSubject.getValue().find(step => step.name == step_name);\r\n\t\tstep?.ready(data);\r\n\t\t/* if (data) {\r\n\t\t\tthis._orderSubject.next(data);\r\n\t\t\tthis.total = data.totals.total;\r\n\t\t} */\r\n\t}\r\n}\r\n"]}

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

@@ -0,0 +1,177 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { ConnectionService } from '../api';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { ChannelService } from './channel.service';
+import { CurrencyStore } from '../stores';
+import * as i0 from "@angular/core";
+/**
+ * Servicio encargado de manejar todo lo que este relacionado a la moneda
+ * que maneja la aplicación.
+ */
+export class CurrencyService {
+    /**
+     * Constantes de core
+     */
+    _consts = inject(CoreConstantsService);
+    /**
+     * Constantes de la API
+     */
+    _apiConsts = inject(ApiConstantsService);
+    /**
+     * Maneja las peticiones a la API
+     */
+    _connection = inject(ConnectionService);
+    /**
+     * Servicio de canales
+     */
+    _channel = inject(ChannelService);
+    /**
+     * Contiene el canal activo de la API.
+     */
+    _channel$ = this._channel.getChannel();
+    /**
+     * Subject para manejar la moneda actual.
+     */
+    _currencySubject = new BehaviorSubject({});
+    /**
+     * Subject para manejar la lista de monedas de la aplicación.
+     */
+    _currencyListSubject = new BehaviorSubject([]);
+    /**
+     * Subject para indicar la actualización de un estado.
+     */
+    _updateSubject = new BehaviorSubject(false);
+    currency$ = this._currencySubject.asObservable();
+    currencyList$ = this._currencyListSubject.asObservable();
+    update$ = this._updateSubject.asObservable();
+    //API URL
+    /**
+     * Devuelve la URL para obtener lista de monedas de la aplicación.
+     * @returns
+     */
+    getCurrencyListApi() { return `${this._apiConsts.SHOP_API_URL}/currencies`; }
+    ;
+    /**
+     * Devuelve la URL para obtener la convertibilidad de una moneda.
+     * @param baseCurrency Moneda base
+     * @param targetCurrency Moneda destino
+     * @returns
+     */
+    getConvertibilityApi(baseCurrency, targetCurrency) { return `${this._apiConsts.SHOP_API_URL}/currencies?baseCurrency=${baseCurrency}&targetCurrency=${targetCurrency}`; }
+    /**
+     * Store que guardara la moneda actual que maneja la aplicación.
+     */
+    currencyStore = inject(CurrencyStore);
+    constructor() {
+        this._channel$.subscribe(channel => {
+            channel.applyCurrencyExchange ? this.loadCurrencyList() : this.loadDefaultCurrency(channel.baseCurrency);
+        });
+    }
+    /**
+       *  Se carga la moneda por defecto.
+       */
+    loadDefaultCurrency(currency) {
+        this._consts.setCurrency(currency);
+        this.load();
+    }
+    /**
+     *  Carga la lista de monedas/currencies.
+     */
+    async loadCurrencyList() {
+        await firstValueFrom(this._connection.get(this.getCurrencyListApi()))
+            .then(res => {
+            this._currencyListSubject.next(res);
+            this._consts.setCurrencyTypeConfig(res);
+            this.load();
+        });
+    }
+    /**
+     *  calcula la convetibilidad del precio  pasado por paramentro segun esta formula:
+     * **c = a * b** donde *c=moneda despues del cambio*, *a=valor que quiero cambiar* y *b=ratio de cambio*.
+     * @param price Precio a cambiar
+     * @param ratio Ratio de cambio
+     * @returns Si el ratio no es null, retorna el precio cambiado, sino retorna el precio sin cambios.
+     */
+    calculateConvetibility(price, ratio) {
+        return ratio ? price * ratio : price;
+    }
+    /**
+     *  genera la carga y configuración de la moneda elegida para la conversion.
+     * @param currency Moneda a convertir.
+     */
+    loadCurrency(currency) {
+        this._currencySubject.next(currency);
+        this._consts.setCurrency(currency.code);
+        let update = this._updateSubject.getValue();
+        this._updateSubject.next(!update);
+        this.currencyStore.add(this._consts.currency);
+    }
+    /**
+     * Genera la convertibilidad de la moneda base a la nueva. Si baseCurrency no tiene valor
+     * entonces utiliza la moneda base del canal.
+     * @param currency Objeto de la moneda destino.
+     * @param baseCurrency Codigo de la moneda base. *Ej: USD | ARS | EUR |...*
+     */
+    async generateConvertibility(currency, baseCurrency) {
+        if (!baseCurrency) {
+            try {
+                baseCurrency = await this._channel.getActiveChannel().baseCurrency;
+            }
+            catch (error) {
+                //console.error(error)
+                baseCurrency = 'USD';
+            }
+        }
+        console.log("BC", baseCurrency);
+        if (currency.code == baseCurrency) {
+            this.loadCurrency(currency);
+        }
+        else {
+            this.getConvertibility(baseCurrency, currency.code);
+        }
+    }
+    /**
+     * Obtiene la conversion desde la moneda base a la destino. Recibe un objeto de tipo CurrencyConfig.
+     * Si la conversion retorna resultado realiza el cambio, de lo contrario emite un mensaje de error.
+     * @param baseCurrency Codigo de la moneda base.
+     * @param targetCurrency Codigo de la moneda destino.
+     */
+    getConvertibility(baseCurrency, targetCurrency) {
+        this._connection.get(this.getConvertibilityApi(baseCurrency, targetCurrency))
+            .toPromise().then(res => {
+            if (res) {
+                let tempCurrency = res[0];
+                this.loadCurrency(tempCurrency);
+            }
+            else {
+                console.error('Error la variable res no contiene valor, asegurese de que esta conversión este configurada en el backoffice');
+                //this.toastr.show('error-convertibility')
+            }
+        }, err => {
+            console.log(err);
+        }).catch(err => console.log(err));
+    }
+    /**
+     * Carga la moneda, si hay una en el localstorage toma esa y realiza la conversion.
+     * de lo contrario solo setea en el observable currencySubject el valor por defecto cargado en las constantes.
+     */
+    load() {
+        let storeCurrency = this.currencyStore.currency();
+        if (storeCurrency && storeCurrency.code) {
+            this.generateConvertibility(storeCurrency);
+        }
+        else {
+            this._currencySubject.next(this._consts.currency);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CurrencyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CurrencyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: CurrencyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/currency.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { ApiConstantsService, CoreConstantsService } from '../constants';\r\nimport { ConnectionService } from '../api';\r\nimport { BehaviorSubject, firstValueFrom, Observable } from 'rxjs';\r\nimport { CurrencyConfig } from '../interfaces';\r\nimport { ChannelService } from './channel.service';\r\nimport { CurrencyStore } from '../stores';\r\n/**\r\n * Servicio encargado de manejar todo lo que este relacionado a la moneda\r\n * que maneja la aplicación.\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class CurrencyService {\r\n    /**\r\n     * Constantes de core\r\n     */\r\n    private _consts: CoreConstantsService = inject(CoreConstantsService)\r\n    /**\r\n     * Constantes de la API\r\n     */\r\n    private _apiConsts: ApiConstantsService = inject(ApiConstantsService)\r\n    /**\r\n     * Maneja las peticiones a la API\r\n     */\r\n    private _connection: ConnectionService = inject(ConnectionService)\r\n    /**\r\n     * Servicio de canales\r\n     */\r\n    private _channel: ChannelService = inject(ChannelService)\r\n    /**\r\n     * Contiene el canal activo de la API.\r\n     */\r\n    private _channel$: Observable<any> = this._channel.getChannel();\r\n    /**\r\n     * Subject para manejar la moneda actual.\r\n     */\r\n    private _currencySubject: BehaviorSubject<CurrencyConfig> = new BehaviorSubject({})\r\n    /**\r\n     * Subject para manejar la lista de monedas de la aplicación.\r\n     */\r\n    private _currencyListSubject: BehaviorSubject<any> = new BehaviorSubject([])\r\n    /**\r\n     * Subject para indicar la actualización de un estado.\r\n     */\r\n    private _updateSubject: BehaviorSubject<boolean> = new BehaviorSubject(false)\r\n\r\n    public currency$: Observable<CurrencyConfig> = this._currencySubject.asObservable()\r\n    public currencyList$: Observable<any[]> = this._currencyListSubject.asObservable()\r\n    public update$: Observable<boolean> = this._updateSubject.asObservable();\r\n\r\n    //API URL\r\n    /**\r\n     * Devuelve la URL para obtener lista de monedas de la aplicación.\r\n     * @returns \r\n     */\r\n    private getCurrencyListApi() { return `${this._apiConsts.SHOP_API_URL}/currencies` };\r\n    /**\r\n     * Devuelve la URL para obtener la convertibilidad de una moneda. \r\n     * @param baseCurrency Moneda base\r\n     * @param targetCurrency Moneda destino\r\n     * @returns \r\n     */\r\n    private getConvertibilityApi(baseCurrency: any, targetCurrency: any) { return `${this._apiConsts.SHOP_API_URL}/currencies?baseCurrency=${baseCurrency}&targetCurrency=${targetCurrency}` }\r\n    /**\r\n     * Store que guardara la moneda actual que maneja la aplicación.\r\n     */\r\n    protected currencyStore = inject(CurrencyStore);\r\n\r\n    constructor() {\r\n        this._channel$.subscribe(channel => {\r\n            channel.applyCurrencyExchange ? this.loadCurrencyList() : this.loadDefaultCurrency(channel.baseCurrency);\r\n        })\r\n    }\r\n\r\n    /**\r\n       *  Se carga la moneda por defecto.\r\n       */\r\n    private loadDefaultCurrency(currency: any) {\r\n        this._consts.setCurrency(currency);\r\n        this.load()\r\n    }\r\n\r\n    /**\r\n     *  Carga la lista de monedas/currencies.\r\n     */\r\n    private async loadCurrencyList() {\r\n        await firstValueFrom(this._connection.get(this.getCurrencyListApi()))\r\n            .then(res => {\r\n                this._currencyListSubject.next(res)\r\n                this._consts.setCurrencyTypeConfig(res)\r\n                this.load()\r\n            })\r\n    }\r\n\r\n    /**\r\n     *  calcula la convetibilidad del precio  pasado por paramentro segun esta formula:\r\n     * **c = a * b** donde *c=moneda despues del cambio*, *a=valor que quiero cambiar* y *b=ratio de cambio*. \r\n     * @param price Precio a cambiar\r\n     * @param ratio Ratio de cambio\r\n     * @returns Si el ratio no es null, retorna el precio cambiado, sino retorna el precio sin cambios. \r\n     */\r\n    public calculateConvetibility(price: number, ratio: number) {\r\n        return ratio ? price * ratio : price;\r\n    }\r\n\r\n    /**\r\n     *  genera la carga y configuración de la moneda elegida para la conversion.\r\n     * @param currency Moneda a convertir.\r\n     */\r\n    private loadCurrency(currency: any) {\r\n        this._currencySubject.next(currency);\r\n        this._consts.setCurrency(currency.code);\r\n        let update = this._updateSubject.getValue()\r\n        this._updateSubject.next(!update)\r\n        this.currencyStore.add(this._consts.currency)\r\n    }\r\n\r\n    /**\r\n     * Genera la convertibilidad de la moneda base a la nueva. Si baseCurrency no tiene valor \r\n     * entonces utiliza la moneda base del canal.\r\n     * @param currency Objeto de la moneda destino.\r\n     * @param baseCurrency Codigo de la moneda base. *Ej: USD | ARS | EUR |...*\r\n     */\r\n    async generateConvertibility(currency: any, baseCurrency?: string) {\r\n        if (!baseCurrency) {\r\n            try {\r\n                baseCurrency = await this._channel.getActiveChannel().baseCurrency;\r\n            } catch (error) {\r\n                //console.error(error)\r\n                baseCurrency = 'USD'\r\n            }\r\n        }\r\n        console.log(\"BC\", baseCurrency);\r\n        if (currency.code == baseCurrency) {\r\n            this.loadCurrency(currency);\r\n        } else {\r\n            this.getConvertibility(baseCurrency, currency.code);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Obtiene la conversion desde la moneda base a la destino. Recibe un objeto de tipo CurrencyConfig.\r\n     * Si la conversion retorna resultado realiza el cambio, de lo contrario emite un mensaje de error.\r\n     * @param baseCurrency Codigo de la moneda base.\r\n     * @param targetCurrency Codigo de la moneda destino.\r\n     */\r\n    private getConvertibility(baseCurrency: any, targetCurrency: any) {\r\n        this._connection.get(this.getConvertibilityApi(baseCurrency, targetCurrency))\r\n            .toPromise().then(\r\n                res => {\r\n                    if (res) {\r\n                        let tempCurrency = res[0]\r\n                        this.loadCurrency(tempCurrency)\r\n                    } else {\r\n                        console.error('Error la variable res no contiene valor, asegurese de que esta conversión este configurada en el backoffice')\r\n                        //this.toastr.show('error-convertibility')\r\n                    }\r\n                },\r\n                err => {\r\n                    console.log(err)\r\n                }\r\n            ).catch(err => console.log(err))\r\n    }\r\n\r\n    /**\r\n     * Carga la moneda, si hay una en el localstorage toma esa y realiza la conversion.\r\n     * de lo contrario solo setea en el observable currencySubject el valor por defecto cargado en las constantes. \r\n     */\r\n    private load() {\r\n        let storeCurrency = this.currencyStore.currency();\r\n        if (storeCurrency && storeCurrency.code) {\r\n            this.generateConvertibility(storeCurrency)\r\n        } else {\r\n            this._currencySubject.next(this._consts.currency)\r\n        }\r\n    }\r\n}\r\n"]}