ng-easycommerce-v18 0.0.1 → 0.0.2

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

@@ -0,0 +1,440 @@
+import { inject, Injectable, PLATFORM_ID, signal } from '@angular/core';
+import { BehaviorSubject, catchError, map, of } from 'rxjs';
+import { ConnectionService } from '../api';
+import { User } from '../classes';
+import moment from 'moment';
+import { ChannelService } from './channel.service';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { LocalStorageService } from './local-storage.service';
+import { AuthStorageService } from './auth.storage.service';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+/**
+ * Servicio de autentificación del usuario en la plataforma.
+ */
+export class AuthService {
+    _localStorage = inject(LocalStorageService);
+    _connection = inject(ConnectionService);
+    _channelService = inject(ChannelService);
+    _constants = inject(CoreConstantsService);
+    _apiConsts = inject(ApiConstantsService);
+    _authStorage = inject(AuthStorageService);
+    // Contantes para el storage.
+    JWT_TOKEN = 'JWT_TOKEN';
+    REFRESH_TOKEN = 'REFRESH_TOKEN';
+    EXPIRATES_IN = 'EXPIRATES_IN';
+    USER = 'USER';
+    MAIL = 'mail';
+    LOCALE = 'LOCALE';
+    CHANNEL = 'CHANNEL';
+    CUSTOMER = 'CUSTOMER';
+    CHANNELSELLER = 'CHANNELSELLER';
+    channelsUserSubject = new BehaviorSubject([]);
+    channels$ = this.channelsUserSubject.asObservable();
+    _channel$ = this._channelService.getChannel();
+    _userInSubject = new BehaviorSubject(null);
+    _loggedInSubject = new BehaviorSubject(false);
+    loggedIn$ = this._loggedInSubject.asObservable();
+    _loggingInSubject = new BehaviorSubject(false);
+    loggingIn$ = this._loggingInSubject.asObservable();
+    /**
+     * Para indicar si un canal cambio.
+     */
+    _activeChannelChange = false;
+    /**
+     * Guarda los datos del usuario
+     */
+    _user = null;
+    _customer = null;
+    /**
+     * Guarda los datos del canal
+     */
+    channel = [];
+    channels = [];
+    /**
+     * Utilizado para resolver hacia donde se tiene que redireccionar
+     * la pagina tras un evento.
+     */
+    _homeResolver;
+    /**
+     * Signal para guardar el token de usuario una vez logueado
+     */
+    _tokenSignal = signal(null);
+    /**
+     * Signal para guardar el usuario
+     */
+    _userSignal = signal(null);
+    //APIs
+    shopApi = this._apiConsts.SHOP_API_URL;
+    channelApi = this._apiConsts.CHANNEL;
+    tokenApi() { return this.shopApi + 'login_check'; }
+    recoverPasswordApi() { return `${this.shopApi}${this.channelApi}/request-password-reset`; }
+    confirmAccountApi(token) { return `${this.shopApi}${this.channelApi}/verify-account?token=${token}`; }
+    registerApi() { return `${this.shopApi}${this.channelApi}/register`; }
+    registerWholesalerApi() { return `${this.shopApi}${this.channelApi}/register-wholesaler`; }
+    platformId = inject(PLATFORM_ID);
+    window;
+    localStorage;
+    constructor() {
+        if (isPlatformBrowser(this.platformId)) {
+            this.window = window;
+            this.localStorage = localStorage;
+        }
+        this.loadTokenFromStorage();
+        this.isAuthenticated() && this._loggedInSubject.next(true);
+    }
+    /**
+     * Loguea al usuario en la aplicación.
+     * @param user datos del usuario
+     * @param withRoles roles del usuario
+     * @returns
+     */
+    login(user, withRoles = []) {
+        this._channel$.subscribe(ch => this.channel = ch);
+        this.channels$.subscribe(ch => this.channels = ch);
+        this._loggingInSubject.next(true);
+        user = { ...user, ...this.loginExtraData() };
+        return this._connection.post(this.tokenApi(), user).pipe(map((res) => {
+            if (this.channelAccessPermission({ ...user, ...res }) && this.isAllowedRole(withRoles, res.type)) {
+                this.doLoginUser({ ...user, ...res });
+                return 'ok';
+            }
+            return 'error';
+        }), catchError((error) => {
+            this._loggingInSubject.next(false);
+            return of(error.toString());
+        }));
+    }
+    /**
+     * Controla que el usuario logueado tenga permisos
+     * para el canal actual de la aplicación.
+     * @param res
+     * @returns
+     */
+    channelAccessPermission(res) {
+        //console.log('channelAccess', res);
+        this.channelsUserSubject.next([]);
+        /* No authorized channels */
+        if (res.channels?.length == 0) {
+            return false;
+        }
+        /* Some authorized channel(s) including current channel */
+        if (res.channels.find((userchannel) => userchannel.code === this.channel.code)) {
+            /* Multiple authorized channels including current channel */
+            if (res.channels?.length > 1 && this._activeChannelChange)
+                this.channelsUserSubject.next(res.channels);
+            return true;
+        }
+        /* One authorized channel not including current channel */
+        if (res.channels?.length == 1 && this._activeChannelChange) {
+            delete res.password;
+            this.channelAccess(res.channels[0], res);
+            return true;
+        }
+        /* Multiple authorized channels not including current channel */
+        if (this._activeChannelChange) {
+            this.channelsUserSubject.next(res.channels);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Controla el acceso al canal, de ser otro nuevo cambia los valores.
+     * @param channel
+     * @param user
+     */
+    channelAccess(channel, user = null) {
+        if (this.window?.location.hostname != channel.hostname) {
+            let encoded = btoa(JSON.stringify(user != null ? user : this._user));
+            this.window?.location.replace(`${this.window?.location.protocol}//${channel.hostname}/auth/redirect/${encoded}`);
+        }
+        else {
+            this._constants.modifyChannelConfig(channel);
+            this.window?.location.reload();
+        }
+    }
+    /**
+     * Controla que el rol del usuario sea un rol permitido por la aplicación.
+     * @param allowedRoles roles que permite la aplicación.
+     * @param role rol del usuarios
+     * @returns
+     */
+    isAllowedRole(allowedRoles, role) {
+        return allowedRoles.length
+            ? allowedRoles.includes(role)
+            : true;
+    }
+    /**
+     * Tras un logueo exitoso, guarda los datos necesarios en el storage y demás
+     * configuraciones necesarias.
+     * @param tokens
+     */
+    doLoginUser(tokens) {
+        this._user = new User();
+        this._user.initilized(tokens);
+        this.forceChannelsForSeller(tokens);
+        //Channel
+        const userJsonify = this._user.jsonify();
+        this._localStorage.setItem(this.USER, JSON.stringify(userJsonify));
+        this._localStorage.setItem(this.EXPIRATES_IN, moment(tokens.expire_in).add(1, 'h').format());
+        this._localStorage.setItem(this.REFRESH_TOKEN, moment(tokens.expire_in).add(1, 'h').format());
+        this._localStorage.setItem(this.JWT_TOKEN, tokens.token);
+        this._authStorage.setAuthToken(tokens.token);
+        this._tokenSignal.set(tokens.token);
+        this._localStorage.setItem(this.MAIL, tokens.username);
+        //Observables
+        this._userInSubject.next(this._user);
+        this._loggedInSubject.next(true);
+        this._loggingInSubject.next(false);
+    }
+    /**
+     * Cambia la funcion que se encarga de resolver hacia donde se redirige el frontend
+     * tras una acción
+     * @param resolverFunction
+     */
+    setHomeResolver(resolverFunction) { this._homeResolver = resolverFunction; }
+    /**
+     * Obtiene la funcion que se encarga de resolver hacia donde se redirige el frontend.
+     * @returns
+     */
+    getHomeResolver() { return this._homeResolver; }
+    /**
+     * Obtiene el token del storage y lo guarda en la signal.
+     */
+    loadTokenFromStorage() {
+        const token = this._localStorage.getItem(this.JWT_TOKEN);
+        if (token) {
+            this._tokenSignal.set(token);
+        }
+    }
+    /**
+     * Desloguea al usuario.
+     */
+    logout() {
+        this.doLogoutUser();
+    }
+    /**
+     * Retorna si hay un usuario logueado o no.
+     * @returns
+     */
+    isAuthenticated() {
+        //console.log("isAuthenticated",this.isTokenExpired(), this._tokenSignal() );
+        if (this.isTokenExpired()) {
+            this.doLogoutUser();
+        }
+        this.getCurrentUserAsUser();
+        this._userInSubject.next(this._user);
+        //console.log(this.getToken(), !this.isTokenExpired() , this._user != null);
+        return this.getToken() && !this.isTokenExpired() && this._user != null;
+    }
+    /**
+     * Retorna el token de usuario
+     * @returns
+     */
+    getToken() {
+        return this._tokenSignal();
+    }
+    /**
+     * Limpia el storage y las configuraciones internas
+     */
+    doLogoutUser() {
+        this._user = null;
+        this._localStorage.removeItem(this.USER);
+        this._localStorage.removeItem(this.EXPIRATES_IN);
+        this._localStorage.removeItem(this.JWT_TOKEN);
+        this._authStorage.setAuthToken(null);
+        this._localStorage.removeItem(this.REFRESH_TOKEN);
+        this._localStorage.removeItem('cart_token');
+        this._localStorage.removeItem(this.MAIL);
+        this._localStorage.removeItem(this.CHANNEL);
+        this._localStorage.removeItem(this.CHANNELSELLER);
+        this._localStorage.removeItem(this.LOCALE);
+        this._localStorage.removeItem(this.CUSTOMER);
+        this._localStorage.removeItem('MASTER_CHANNEL');
+        this._loggedInSubject.next(false);
+        this._userInSubject.next(this._user);
+        this.channelsUserSubject.next([]);
+        this._tokenSignal.set(null);
+    }
+    /**
+     * Devuelve `true`si el token expiro, `false` caso contrario.
+     * @returns
+     */
+    isTokenExpired() {
+        const fecha_expiracion = this.getExpiratesAt();
+        const result = moment() >= moment(fecha_expiracion);
+        return result;
+    }
+    /**
+     * Obtiene la fecha de expiración del token.
+     * @returns
+     */
+    getExpiratesAt() {
+        return this._localStorage.getItem(this.EXPIRATES_IN);
+    }
+    /**
+     * Obtiene al usuario actual y lo convierte en una instancia de `User`
+     * @returns
+     */
+    getCurrentUserAsUser() {
+        this._user = new User();
+        if (!this.loadUserFromStorage()) {
+            this._user = null;
+        }
+        else if (this._user?.channels.find((userchannel) => userchannel?.code === this._apiConsts.CHANNEL)) {
+            return this._user;
+        }
+        else {
+            this.logout();
+        }
+        return this._user;
+    }
+    /**
+     * Obtiene el usuario del storage.
+     * @param key
+     * @returns
+     */
+    loadUserFromStorage(key = this.USER) {
+        if (this._localStorage.getItem(key)) {
+            this._user = JSON.parse(this._localStorage.getItem(key));
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Envia la solicitud para cambiar la contraseña.
+     * @param email email del solicitante.
+     * @returns
+     */
+    recoverPassword(email) {
+        return this._connection.put(this.recoverPasswordApi(), { email });
+    }
+    /**
+     * Para confirmar el registro de usuario.
+     * @param token
+     * @returns
+     */
+    confirmAccount(token) {
+        return this._connection.get(this.confirmAccountApi(token));
+    }
+    /**
+     * Para registrar a un usuario común
+     * @param data
+     * @returns
+     */
+    singUp(data) {
+        return this._connection.post(this.registerApi(), data);
+    }
+    /**
+     * Para registrar a un usuario mayorista.
+     * @param data
+     * @returns
+     */
+    signUpWholesaler(data) {
+        return this._connection.post(this.registerWholesalerApi(), data);
+    }
+    /**
+     * Chequea si un usuario esta habilitado a comprar o no.
+     * @returns
+     */
+    isAbleToBuy() {
+        const currentUser = this.getUserProfileAsUser();
+        const isSeller = currentUser.typeUser && currentUser.typeUser == 'seller' || false;
+        return !isSeller || !this.getCustomer();
+    }
+    /**
+     * Retorna un usuario de tipo cliente.
+     * @returns
+     */
+    getCustomer() {
+        return this._customer || JSON.parse(this._localStorage.getItem(this.CUSTOMER));
+    }
+    /**
+     * Devuelve el usuario actual logueado.
+     * @returns
+     */
+    getUserProfileAsUser() {
+        return this._user || this.getCurrentUserAsUser();
+    }
+    /**
+     * Agrega data extra al objecto de Usuario.
+     * @returns
+     */
+    loginExtraData = () => {
+        return {
+            client_id: 'demo_client',
+            client_secret: 'secret_demo_client',
+            grant_type: 'password'
+        };
+    };
+    /* Please remove this ASAP - Needs *channels* array in user object ALWAYS */
+    forceChannelsForSeller(tokens) {
+        if ("seller" /* UserRoleType.SELLER */ == tokens.type)
+            this.channels?.length
+                ? this._user.setChannels(...this.channels)
+                : this._user.setChannels(this.channel);
+    }
+    /**
+    * Carga el cliente con el que se realizaran pedidos. Si recibe el valor null
+    * se vuelve a cargar el vendedor para su uso.
+    * @param customer
+    */
+    setCustomer(customer) {
+        let refreshPage = false;
+        this._customer = customer;
+        this._localStorage.setItem(this.CUSTOMER, JSON.stringify(customer));
+        let sameChannel = customer ? this.sameChannel(customer.channels[0].code, customer.channels[0].locales.code) : null;
+        if (customer) {
+            if (!sameChannel) {
+                !this.localStorage?.getItem(this.CHANNELSELLER) ?
+                    this.localStorage?.setItem(this.CHANNELSELLER, JSON.stringify({
+                        channel: this._apiConsts.CHANNEL,
+                        locale: this._apiConsts.LOCALE
+                    })) : null;
+                this.changeChannel({
+                    channel: customer.channels[0].code,
+                    locale: customer.channels[0].locales.code
+                });
+                refreshPage = true;
+            }
+        }
+        else {
+            let res = JSON.parse(this._localStorage.getItem(this.CHANNELSELLER));
+            if (res) {
+                if (!this.sameChannel(res.channel, res.locale)) {
+                    this.changeChannel(res);
+                    refreshPage = true;
+                }
+                this.localStorage?.removeItem(this.CHANNELSELLER);
+            }
+        }
+        //this._cartService.clearAndResetCustomerCart()
+        refreshPage ? location.href = location.href : null;
+    }
+    /**
+     * Comprueba si los valores del canal actual son iguales a los ingresado por parametros.
+     * @param {string} channel Nombre del canal
+     * @param {string} locale  Locale del canal
+     * @returns {boolean} True si es el mismo canal, False caso contrario.
+     */
+    sameChannel = (channel, locale) => (channel == this._apiConsts.CHANNEL) && (locale == this._apiConsts.LOCALE);
+    /**
+     * Cambia de canal
+     * @param channelConfig debe ser un objeto que contenga al menos las keys channel y locale.
+     */
+    changeChannel = (channelConfig) => {
+        this._constants.modifyChannelConfig({
+            channel: channelConfig.channel,
+            locale: channelConfig.locale
+        });
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/ng-easycommerce-v18/src/lib/ec-services/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, PLATFORM_ID, signal } from '@angular/core';\nimport { UserRoleType } from '../interfaces';\nimport { BehaviorSubject, catchError, map, Observable, of } from 'rxjs';\nimport { ConnectionService } from '../api';\nimport { User } from '../classes';\nimport moment from 'moment';\nimport { ChannelService } from './channel.service';\nimport { ApiConstantsService, CoreConstantsService } from '../constants';\nimport { LocalStorageService } from './local-storage.service';\nimport { AuthStorageService } from './auth.storage.service';\nimport { CartService } from './cart.service';\nimport { isPlatformBrowser } from '@angular/common';\n/**\n * Servicio de autentificación del usuario en la plataforma.\n */\n@Injectable({\n\tprovidedIn: 'root'\n})\nexport class AuthService {\n\tprivate _localStorage: LocalStorageService = inject(LocalStorageService)\n\tprivate _connection: ConnectionService = inject(ConnectionService);\n\tprivate _channelService: ChannelService = inject(ChannelService);\n\tprivate _constants: CoreConstantsService = inject(CoreConstantsService);\n\tprivate _apiConsts: ApiConstantsService = inject(ApiConstantsService);\n\tprivate _authStorage: AuthStorageService = inject(AuthStorageService);\n\n\t// Contantes para el storage.\n\tprivate readonly JWT_TOKEN = 'JWT_TOKEN'\n\tprivate readonly REFRESH_TOKEN = 'REFRESH_TOKEN'\n\tprivate readonly EXPIRATES_IN = 'EXPIRATES_IN'\n\tprivate readonly USER = 'USER'\n\tprivate readonly MAIL = 'mail'\n\tprivate readonly LOCALE = 'LOCALE'\n\tprivate readonly CHANNEL = 'CHANNEL'\n\tprivate readonly CUSTOMER = 'CUSTOMER'\n\tprivate readonly CHANNELSELLER = 'CHANNELSELLER'\n\n\tprivate channelsUserSubject = new BehaviorSubject<any[]>([])\n\tpublic channels$ = this.channelsUserSubject.asObservable()\n\tprivate _channel$ = this._channelService.getChannel()\n\tprivate _userInSubject = new BehaviorSubject<User | null>(null)\n\tprivate _loggedInSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n\tpublic loggedIn$: Observable<boolean> = this._loggedInSubject.asObservable();\n\tprivate _loggingInSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);\n\tpublic loggingIn$: Observable<boolean> = this._loggingInSubject.asObservable();\n\n\t/**\n\t * Para indicar si un canal cambio.\n\t */\n\tprivate _activeChannelChange: boolean = false;\n\t/**\n\t * Guarda los datos del usuario\n\t */\n\tprivate _user: User | null = null;\n\tprivate _customer = null;\n\t/**\n\t * Guarda los datos del canal\n\t */\n\tpublic channel: any = []\n\tpublic channels: any[] = []\n\t/**\n\t * Utilizado para resolver hacia donde se tiene que redireccionar\n\t * la pagina tras un evento.\n\t */\n\tprivate _homeResolver: any;\n\t/**\n\t * Signal para guardar el token de usuario una vez logueado\n\t */\n\tprivate _tokenSignal = signal<string | null>(null);\n\t/**\n\t * Signal para guardar el usuario\n\t */\n\tprivate _userSignal = signal<User | null>(null);\n\t//APIs\n\tprivate shopApi: string = this._apiConsts.SHOP_API_URL\n\tprivate channelApi: string = this._apiConsts.CHANNEL\n\tprivate tokenApi() { return this.shopApi + 'login_check' }\n\tprivate recoverPasswordApi() { return `${this.shopApi}${this.channelApi}/request-password-reset` }\n\tprivate confirmAccountApi(token: string) { return `${this.shopApi}${this.channelApi}/verify-account?token=${token}` }\n\tprivate registerApi() { return `${this.shopApi}${this.channelApi}/register` }\n\tprivate registerWholesalerApi() { return `${this.shopApi}${this.channelApi}/register-wholesaler`}\n\tprivate platformId: any = inject(PLATFORM_ID)\n\t\n\tpublic window?:Window;\n\tpublic localStorage?:Storage;\n\tconstructor() {\n\t\tif (isPlatformBrowser(this.platformId)) {\n\t\t\tthis.window = window\n\t\t\tthis.localStorage = localStorage;\n\t\t}\n\t\tthis.loadTokenFromStorage();\n\t\tthis.isAuthenticated() && this._loggedInSubject.next(true);\n\t}\n\t/**\n\t * Loguea al usuario en la aplicación.\n\t * @param user datos del usuario\n\t * @param withRoles roles del usuario\n\t * @returns \n\t */\n\tlogin(user: { username: string, password: string }, withRoles: UserRoleType[] = []): Observable<any> {\n\t\tthis._channel$.subscribe(ch => this.channel = ch);\n\t\tthis.channels$.subscribe(ch => this.channels = ch);\n\t\tthis._loggingInSubject.next(true);\n\t\tuser = {...user, ...this.loginExtraData() }\n\t\treturn this._connection.post(this.tokenApi(), user).pipe(\n\t\t\tmap((res: any) => {\n\t\t\t\tif (this.channelAccessPermission({ ...user, ...res }) && this.isAllowedRole(withRoles, res.type)) {\n\t\t\t\t\tthis.doLoginUser({ ...user, ...res });\n\t\t\t\t\treturn 'ok';\n\t\t\t\t}\n\t\t\t\treturn 'error';\n\t\t\t}),\n\t\t\tcatchError((error: any) => {\n\t\t\t\tthis._loggingInSubject.next(false);\n\t\t\t\treturn of(error.toString());\n\t\t\t})\n\t\t)\n\t}\n\t/**\n\t * Controla que el usuario logueado tenga permisos \n\t * para el canal actual de la aplicación.\n\t * @param res \n\t * @returns \n\t */\n\tprivate channelAccessPermission(res: any) {\n\t\t//console.log('channelAccess', res);\n\t\tthis.channelsUserSubject.next([]);\n\n\t\t/* No authorized channels */\n\t\tif (res.channels?.length == 0) {\n\t\t\treturn false\n\t\t}\n\t\t/* Some authorized channel(s) including current channel */\n\t\tif (res.channels.find((userchannel: any) => userchannel.code === this.channel.code)) {\n\t\t\t/* Multiple authorized channels including current channel */\n\t\t\tif (res.channels?.length > 1 && this._activeChannelChange)\n\t\t\t\tthis.channelsUserSubject.next(res.channels)\n\t\t\treturn true\n\t\t}\n\t\t/* One authorized channel not including current channel */\n\t\tif (res.channels?.length == 1 && this._activeChannelChange) {\n\t\t\tdelete res.password\n\t\t\tthis.channelAccess(res.channels[0], res)\n\t\t\treturn true\n\t\t}\n\t\t/* Multiple authorized channels not including current channel */\n\t\tif (this._activeChannelChange) {\n\t\t\tthis.channelsUserSubject.next(res.channels)\n\t\t\treturn true\n\t\t}\n\t\treturn false\n\t}\n\t/**\n\t * Controla el acceso al canal, de ser otro nuevo cambia los valores.\n\t * @param channel \n\t * @param user \n\t */\n\tchannelAccess(channel: any, user = null) {\n\t\tif (this.window?.location.hostname != channel.hostname) {\n\t\t\tlet encoded = btoa(JSON.stringify(user != null ? user : this._user))\n\t\t\tthis.window?.location.replace(`${this.window?.location.protocol}//${channel.hostname}/auth/redirect/${encoded}`)\n\t\t} else {\n\t\t\tthis._constants.modifyChannelConfig(channel)\n\t\t\tthis.window?.location.reload()\n\t\t}\n\t}\n\t/**\n\t * Controla que el rol del usuario sea un rol permitido por la aplicación.\n\t * @param allowedRoles roles que permite la aplicación.\n\t * @param role rol del usuarios\n\t * @returns \n\t */\n\tprivate isAllowedRole(allowedRoles: UserRoleType[], role: string) {\n\t\treturn allowedRoles.length\n\t\t\t? allowedRoles.includes(role as UserRoleType)\n\t\t\t: true\n\t}\n\t/**\n\t * Tras un logueo exitoso, guarda los datos necesarios en el storage y demás\n\t * configuraciones necesarias.\n\t * @param tokens \n\t */\n\tprivate doLoginUser(tokens: any) {\n\t\tthis._user = new User()\n\t\tthis._user.initilized(tokens)\n\t\t\n\t\tthis.forceChannelsForSeller(tokens)\n\t\t//Channel\n\t\tconst userJsonify = this._user.jsonify()\n\t\tthis._localStorage.setItem(this.USER, JSON.stringify(userJsonify))\n\t\tthis._localStorage.setItem(this.EXPIRATES_IN, moment(tokens.expire_in).add(1, 'h').format());\n\t\tthis._localStorage.setItem(this.REFRESH_TOKEN, moment(tokens.expire_in).add(1, 'h').format());\n\t\tthis._localStorage.setItem(this.JWT_TOKEN, tokens.token);\n\t\tthis._authStorage.setAuthToken(tokens.token)\n\t\tthis._tokenSignal.set(tokens.token);\n\t\tthis._localStorage.setItem(this.MAIL, tokens.username);\n\t\t//Observables\n\t\tthis._userInSubject.next(this._user);\n\t\tthis._loggedInSubject.next(true);\n\t\tthis._loggingInSubject.next(false);\n\t}\n\t/**\n\t * Cambia la funcion que se encarga de resolver hacia donde se redirige el frontend\n\t * tras una acción\n\t * @param resolverFunction \n\t */\n\tpublic setHomeResolver(resolverFunction: any) { this._homeResolver = resolverFunction }\n\t/**\n\t * Obtiene la funcion que se encarga de resolver hacia donde se redirige el frontend.\n\t * @returns \n\t */\n\tpublic getHomeResolver() { return this._homeResolver }\n\t/**\n\t * Obtiene el token del storage y lo guarda en la signal.\n\t */\n\tpublic loadTokenFromStorage() {\n\t\tconst token = this._localStorage.getItem(this.JWT_TOKEN);\n\t\tif (token) {\n\t\t\tthis._tokenSignal.set(token);\n\t\t}\n\t}\n\t/**\n\t * Desloguea al usuario.\n\t */\n\tpublic logout() {\n\t\tthis.doLogoutUser();\n\t}\n\t/**\n\t * Retorna si hay un usuario logueado o no.\n\t * @returns \n\t */\n\tpublic isAuthenticated(): boolean {\n\t\t//console.log(\"isAuthenticated\",this.isTokenExpired(), this._tokenSignal() );\n\t\tif (this.isTokenExpired()) {\n\t\t\tthis.doLogoutUser()\n\t\t}\n\t\tthis.getCurrentUserAsUser()\n\t\tthis._userInSubject.next(this._user);\n\t\t//console.log(this.getToken(), !this.isTokenExpired() , this._user != null);\n\t\treturn this.getToken() && !this.isTokenExpired() && this._user != null;\n\t}\n\t/**\n\t * Retorna el token de usuario\n\t * @returns \n\t */\n\tpublic getToken(): any {\n\t\treturn this._tokenSignal();\n\t}\n\t/**\n\t * Limpia el storage y las configuraciones internas\n\t */\n\tpublic doLogoutUser() {\n\t\tthis._user = null\n\t\tthis._localStorage.removeItem(this.USER);\n\t\tthis._localStorage.removeItem(this.EXPIRATES_IN);\n\t\tthis._localStorage.removeItem(this.JWT_TOKEN);\n\t\tthis._authStorage.setAuthToken(null);\n\t\tthis._localStorage.removeItem(this.REFRESH_TOKEN);\n\t\tthis._localStorage.removeItem('cart_token');\n\t\tthis._localStorage.removeItem(this.MAIL);\n\t\tthis._localStorage.removeItem(this.CHANNEL);\n\t\tthis._localStorage.removeItem(this.CHANNELSELLER);\n\t\tthis._localStorage.removeItem(this.LOCALE);\n\t\tthis._localStorage.removeItem(this.CUSTOMER);\n\t\tthis._localStorage.removeItem('MASTER_CHANNEL');\n\t\tthis._loggedInSubject.next(false);\n\t\tthis._userInSubject.next(this._user);\n\t\tthis.channelsUserSubject.next([])\n\t\tthis._tokenSignal.set(null)\n\t}\n\t/**\n\t * Devuelve `true`si el token expiro, `false` caso contrario.\n\t * @returns \n\t */\n\tprivate isTokenExpired() {\n\t\tconst fecha_expiracion = this.getExpiratesAt();\n\t\tconst result = moment() >= moment(fecha_expiracion);\n\t\treturn result;\n\t}\n\t/**\n\t * Obtiene la fecha de expiración del token.\n\t * @returns \n\t */\n\tprivate getExpiratesAt() {\n\t\treturn this._localStorage.getItem(this.EXPIRATES_IN);\n\t}\n\t/**\n\t * Obtiene al usuario actual y lo convierte en una instancia de `User`\n\t * @returns \n\t */\n\tprivate getCurrentUserAsUser(): User | null {\n\t\tthis._user = new User();\n\t\tif (!this.loadUserFromStorage()) {\n\t\t\tthis._user = null\n\t\t}\n\t\telse if (this._user?.channels.find((userchannel: any) => userchannel?.code === this._apiConsts.CHANNEL)) {\n\t\t\treturn this._user;\n\t\t} else {\n\t\t\tthis.logout()\n\t\t}\n\t\treturn this._user;\n\t}\n\t/**\n\t * Obtiene el usuario del storage.\n\t * @param key \n\t * @returns \n\t */\n\tprivate loadUserFromStorage(key = this.USER) {\n\t\tif (this._localStorage.getItem(key)) {\n\t\t\tthis._user = JSON.parse(this._localStorage.getItem(key));\n\t\t\treturn true\n\t\t}\n\t\treturn false\n\t}\n\t/**\n\t * Envia la solicitud para cambiar la contraseña.\n\t * @param email email del solicitante.\n\t * @returns \n\t */\n\trecoverPassword(email: string) {\n\t\treturn this._connection.put(this.recoverPasswordApi(), { email });\n\t}\n\t/**\n\t * Para confirmar el registro de usuario.\n\t * @param token \n\t * @returns \n\t */\n\tconfirmAccount(token: string) {\n\t\treturn this._connection.get(this.confirmAccountApi(token));\n\t}\n\t/**\n\t * Para registrar a un usuario común\n\t * @param data \n\t * @returns \n\t */\n\tsingUp(data: any) {\n\t\treturn this._connection.post(this.registerApi(), data);\n\t}\n\t/**\n\t * Para registrar a un usuario mayorista.\n\t * @param data \n\t * @returns \n\t */\n\tsignUpWholesaler(data: any) {\n\t\treturn this._connection.post(this.registerWholesalerApi(),data);\n\t}\n\t/**\n\t * Chequea si un usuario esta habilitado a comprar o no.\n\t * @returns \n\t */\n\tisAbleToBuy():boolean {\n\t\tconst currentUser = this.getUserProfileAsUser() as User;\n\t\tconst isSeller = currentUser.typeUser && currentUser.typeUser == 'seller' || false\n\t\treturn !isSeller || !this.getCustomer();\n\t}\n\t/**\n\t * Retorna un usuario de tipo cliente.\n\t * @returns \n\t */\n\tgetCustomer() {\n\t\treturn this._customer || JSON.parse(this._localStorage.getItem(this.CUSTOMER))\n\t}\n\t/**\n\t * Devuelve el usuario actual logueado.\n\t * @returns \n\t */\n\tgetUserProfileAsUser(): User {\n        return this._user! as User || this.getCurrentUserAsUser();\n    }\n\t/**\n\t * Agrega data extra al objecto de Usuario.\n\t * @returns \n\t */\n\tloginExtraData = () => {\n        return {\n            client_id: 'demo_client',\n            client_secret: 'secret_demo_client',\n            grant_type: 'password'\n        }\n    }\n\t/* Please remove this ASAP - Needs *channels* array in user object ALWAYS */\n    private forceChannelsForSeller(tokens:any){\n        if (UserRoleType.SELLER == tokens.type as UserRoleType)\n            this.channels?.length\n                ? this._user!.setChannels(...this.channels)\n                : this._user!.setChannels(this.channel)\n    }\n\n\t /**\n     * Carga el cliente con el que se realizaran pedidos. Si recibe el valor null\n     * se vuelve a cargar el vendedor para su uso.  \n     * @param customer \n     */\n\t public setCustomer(customer:any){\n        let refreshPage = false\n        this._customer = customer\n        this._localStorage.setItem(this.CUSTOMER, JSON.stringify(customer))\n        \n        let sameChannel = customer ? this.sameChannel(customer.channels[0].code, customer.channels[0].locales.code) : null\n        \n        if (customer) {\n            if(!sameChannel){\n                !this.localStorage?.getItem(this.CHANNELSELLER) ?\n                    this.localStorage?.setItem(this.CHANNELSELLER, JSON.stringify({\n                        channel: this._apiConsts.CHANNEL,\n                        locale: this._apiConsts.LOCALE\n                    })) : null;\n                this.changeChannel({\n                    channel: customer.channels[0].code,\n                    locale: customer.channels[0].locales.code\n                })\n                refreshPage = true\n            }\n        } else {\n            let res = JSON.parse(this._localStorage.getItem(this.CHANNELSELLER))\n            if(res){\n                if(!this.sameChannel(res.channel, res.locale)){\n                    this.changeChannel(res)\n                    refreshPage = true\n                }\n                this.localStorage?.removeItem(this.CHANNELSELLER);\n            }\n        }\n        //this._cartService.clearAndResetCustomerCart()\n        refreshPage ? location.href = location.href : null\n    }\n\n\t/**\n     * Comprueba si los valores del canal actual son iguales a los ingresado por parametros.\n     * @param {string} channel Nombre del canal\n     * @param {string} locale  Locale del canal\n     * @returns {boolean} True si es el mismo canal, False caso contrario.\n     */\n    private sameChannel = (channel:string, locale:string):boolean => (channel == this._apiConsts.CHANNEL) && (locale == this._apiConsts.LOCALE)\n\n\t/**\n     * Cambia de canal\n     * @param channelConfig debe ser un objeto que contenga al menos las keys channel y locale.\n     */\n    private changeChannel = (channelConfig:any) => {\n        this._constants.modifyChannelConfig({\n            channel: channelConfig.channel,\n            locale: channelConfig.locale\n        })\n    }\n}\n"]}

package/esm2022/lib/ec-services/auth.storage.service.mjs

@@ -0,0 +1,54 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { LocalStorageService } from './local-storage.service';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+export class AuthStorageService {
+    _localStorage = inject(LocalStorageService);
+    _authTokenSubject = new BehaviorSubject(null);
+    // Contantes para el storage.
+    JWT_TOKEN = 'JWT_TOKEN';
+    REFRESH_TOKEN = 'REFRESH_TOKEN';
+    EXPIRATES_IN = 'EXPIRATES_IN';
+    constructor() { }
+    setAuthToken(token) {
+        this._authTokenSubject.next(token);
+    }
+    getAuthToken$() {
+        return this._authTokenSubject.asObservable();
+    }
+    getAuthToken() {
+        if (!this._authTokenSubject.value) {
+            const res = this._localStorage.getItem(this.JWT_TOKEN);
+            return res ? res : null;
+        }
+        else {
+            return this._authTokenSubject.value;
+        }
+    }
+    /**
+     * Devuelve `true`si el token expiro, `false` caso contrario.
+     * @returns
+     */
+    isTokenExpired() {
+        const fecha_expiracion = this.getExpiratesAt();
+        const result = moment() >= moment(fecha_expiracion);
+        return result;
+    }
+    /**
+     * Obtiene la fecha de expiración del token.
+     * @returns
+     */
+    getExpiratesAt() {
+        return this._localStorage.getItem(this.EXPIRATES_IN);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AuthStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService } from '../constants';
+import { BehaviorSubject, map, shareReplay } from 'rxjs';
+import { ConnectionService } from '../api';
+import * as i0 from "@angular/core";
+/**
+ * Servicio que maneja los bloques como repositorio.
+ * @class BlocksRepositoryService
+ */
+export class BlocksRepositoryService {
+    /**
+     * Constantes de la API
+     */
+    apiConstants = inject(ApiConstantsService);
+    /**
+     * Menaja las conexiones con la API
+     */
+    connection = inject(ConnectionService);
+    /**
+     * Subject para manejar los bloques recibidos.
+     */
+    blocksSubject = new BehaviorSubject([]);
+    /**
+     * Observable de bloques.
+     */
+    blocks$ = this.blocksSubject.asObservable();
+    //API URLS
+    /**
+     * Devuelve la url para obtener los bloques segun la sección.
+     * @param section
+     * @returns
+     */
+    blocksAPI(section) { return `${this.apiConstants.CMS_URL}${this.apiConstants.CHANNEL}/blocks/section/${section}?locale=${this.apiConstants.LOCALE}`; }
+    /**
+     * Obtiene los bloques segun la seccion del Backend.
+     * @param section
+     * @returns Un observable de los bloques.
+     */
+    getBlocks(section) {
+        //if(this.blocksSubject.getValue() != null){
+        this.connection.get(this.blocksAPI(section)).pipe(shareReplay(1), map((response) => {
+            //console.log(response)
+            this.blocksSubject.next(response.items);
+            return response;
+        })).subscribe();
+        //}
+        return this.blocks$;
+    }
+    /* private hasSectionBlocks = (section: string) => {
+        
+    } */
+    appendBlock = (blocks, section) => {
+        const new_block = { section, blocks };
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksRepositoryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksRepositoryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: BlocksRepositoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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