ng-easycommerce-v18 0.0.1

package/projects/ng-easycommerce/src/lib/ec-services/analytics/metricool-pixel.service.ts

@@ -0,0 +1,46 @@
+import { DOCUMENT } from '@angular/common';
+import { inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';
+/**
+ * Servicio encargado de manejar el analytics de Metricool Pixel
+ */
+@Injectable({
+	providedIn: 'root'
+})
+export class MetricoolPixelService {
+    /**
+     * Indica si se esta cargando el Servicio.
+     */
+	private isLoaded = false;
+
+	private rendererFactory: RendererFactory2 = inject(RendererFactory2)
+	private document: any = inject(DOCUMENT)
+    /**
+	 * Se encarga de crear el elemento HTML con las configuraciones para 
+	 * que se pueda ejecutar el servicio.
+	 */
+	private renderer: Renderer2;
+
+	constructor() {
+		this.renderer = this.rendererFactory.createRenderer(null, null);
+	}
+    /**
+     * Inicializa el Servicio de analytics con sus configuraciones.
+     * @param pixel_hash hash provisto por Metricool Pixel.
+     */
+	initialize = (pixel_hash:any) => {
+        let new_analityc_script = this.renderer.createElement('script');
+        new_analityc_script.type = 'text/javascript';
+        new_analityc_script.text = `
+        function loadScript(a) {
+            var b = document.getElementsByTagName("head")[0], c = document.createElement("script");
+            c.type = "text/javascript",
+                c.src = "https://tracker.metricool.com/resources/be.js",
+                c.onreadystatechange = a,
+                c.onload = a, b.appendChild(c)
+        } loadScript(function () {
+            beTracker.t({ hash: "${pixel_hash}" })
+        });
+        `;
+        this.renderer.appendChild(this.document.body, new_analityc_script);
+    }
+}

package/projects/ng-easycommerce/src/lib/ec-services/auth.service.ts

@@ -0,0 +1,438 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { UserRoleType } from '../interfaces';
+import { BehaviorSubject, catchError, map, Observable, 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 { CartService } from './cart.service';
+/**
+ * Servicio de autentificación del usuario en la plataforma.
+ */
+@Injectable({
+	providedIn: 'root'
+})
+export class AuthService {
+	private _localStorage: LocalStorageService = inject(LocalStorageService)
+	private _connection: ConnectionService = inject(ConnectionService);
+	private _channelService: ChannelService = inject(ChannelService);
+	private _constants: CoreConstantsService = inject(CoreConstantsService);
+	private _apiConsts: ApiConstantsService = inject(ApiConstantsService);
+	private _authStorage: AuthStorageService = inject(AuthStorageService);
+
+	// Contantes para el storage.
+	private readonly JWT_TOKEN = 'JWT_TOKEN'
+	private readonly REFRESH_TOKEN = 'REFRESH_TOKEN'
+	private readonly EXPIRATES_IN = 'EXPIRATES_IN'
+	private readonly USER = 'USER'
+	private readonly MAIL = 'mail'
+	private readonly LOCALE = 'LOCALE'
+	private readonly CHANNEL = 'CHANNEL'
+	private readonly CUSTOMER = 'CUSTOMER'
+	private readonly CHANNELSELLER = 'CHANNELSELLER'
+
+	private channelsUserSubject = new BehaviorSubject<any[]>([])
+	public channels$ = this.channelsUserSubject.asObservable()
+	private _channel$ = this._channelService.getChannel()
+	private _userInSubject = new BehaviorSubject<User | null>(null)
+	private _loggedInSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+	public loggedIn$: Observable<boolean> = this._loggedInSubject.asObservable();
+	private _loggingInSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+	public loggingIn$: Observable<boolean> = this._loggingInSubject.asObservable();
+
+	/**
+	 * Para indicar si un canal cambio.
+	 */
+	private _activeChannelChange: boolean = false;
+	/**
+	 * Guarda los datos del usuario
+	 */
+	private _user: User | null = null;
+	private _customer = null;
+	/**
+	 * Guarda los datos del canal
+	 */
+	public channel: any = []
+	public channels: any[] = []
+	/**
+	 * Utilizado para resolver hacia donde se tiene que redireccionar
+	 * la pagina tras un evento.
+	 */
+	private _homeResolver: any;
+	/**
+	 * Signal para guardar el token de usuario una vez logueado
+	 */
+	private _tokenSignal = signal<string | null>(null);
+	/**
+	 * Signal para guardar el usuario
+	 */
+	private _userSignal = signal<User | null>(null);
+	//APIs
+	private shopApi: string = this._apiConsts.SHOP_API_URL
+	private channelApi: string = this._apiConsts.CHANNEL
+	private tokenApi() { return this.shopApi + 'login_check' }
+	private recoverPasswordApi() { return `${this.shopApi}${this.channelApi}/request-password-reset` }
+	private confirmAccountApi(token: string) { return `${this.shopApi}${this.channelApi}/verify-account?token=${token}` }
+	private registerApi() { return `${this.shopApi}${this.channelApi}/register` }
+	private registerWholesalerApi() { return `${this.shopApi}${this.channelApi}/register-wholesaler`}
+
+	constructor() {
+		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: { username: string, password: string }, withRoles: UserRoleType[] = []): Observable<any> {
+		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: any) => {
+				if (this.channelAccessPermission({ ...user, ...res }) && this.isAllowedRole(withRoles, res.type)) {
+					this.doLoginUser({ ...user, ...res });
+					return 'ok';
+				}
+				return 'error';
+			}),
+			catchError((error: any) => {
+				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 
+	 */
+	private channelAccessPermission(res: any) {
+		//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: any) => 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: any, user = null) {
+		if (window.location.hostname != channel.hostname) {
+			let encoded = btoa(JSON.stringify(user != null ? user : this._user))
+			window.location.replace(`${window.location.protocol}//${channel.hostname}/auth/redirect/${encoded}`)
+		} else {
+			this._constants.modifyChannelConfig(channel)
+			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 
+	 */
+	private isAllowedRole(allowedRoles: UserRoleType[], role: string) {
+		return allowedRoles.length
+			? allowedRoles.includes(role as UserRoleType)
+			: true
+	}
+	/**
+	 * Tras un logueo exitoso, guarda los datos necesarios en el storage y demás
+	 * configuraciones necesarias.
+	 * @param tokens 
+	 */
+	private doLoginUser(tokens: any) {
+		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 
+	 */
+	public setHomeResolver(resolverFunction: any) { this._homeResolver = resolverFunction }
+	/**
+	 * Obtiene la funcion que se encarga de resolver hacia donde se redirige el frontend.
+	 * @returns 
+	 */
+	public getHomeResolver() { return this._homeResolver }
+	/**
+	 * Obtiene el token del storage y lo guarda en la signal.
+	 */
+	public loadTokenFromStorage() {
+		const token = this._localStorage.getItem(this.JWT_TOKEN);
+		if (token) {
+			this._tokenSignal.set(token);
+		}
+	}
+	/**
+	 * Desloguea al usuario.
+	 */
+	public logout() {
+		this.doLogoutUser();
+	}
+	/**
+	 * Retorna si hay un usuario logueado o no.
+	 * @returns 
+	 */
+	public isAuthenticated(): boolean {
+		//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 
+	 */
+	public getToken(): any {
+		return this._tokenSignal();
+	}
+	/**
+	 * Limpia el storage y las configuraciones internas
+	 */
+	public 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 
+	 */
+	private isTokenExpired() {
+		const fecha_expiracion = this.getExpiratesAt();
+		const result = moment() >= moment(fecha_expiracion);
+		return result;
+	}
+	/**
+	 * Obtiene la fecha de expiración del token.
+	 * @returns 
+	 */
+	private getExpiratesAt() {
+		return this._localStorage.getItem(this.EXPIRATES_IN);
+	}
+	/**
+	 * Obtiene al usuario actual y lo convierte en una instancia de `User`
+	 * @returns 
+	 */
+	private getCurrentUserAsUser(): User | null {
+		this._user = new User();
+		if (!this.loadUserFromStorage()) {
+			this._user = null
+		}
+		else if (this._user?.channels.find((userchannel: any) => userchannel?.code === this._apiConsts.CHANNEL)) {
+			return this._user;
+		} else {
+			this.logout()
+		}
+		return this._user;
+	}
+	/**
+	 * Obtiene el usuario del storage.
+	 * @param key 
+	 * @returns 
+	 */
+	private 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: string) {
+		return this._connection.put(this.recoverPasswordApi(), { email });
+	}
+	/**
+	 * Para confirmar el registro de usuario.
+	 * @param token 
+	 * @returns 
+	 */
+	confirmAccount(token: string) {
+		return this._connection.get(this.confirmAccountApi(token));
+	}
+	/**
+	 * Para registrar a un usuario común
+	 * @param data 
+	 * @returns 
+	 */
+	singUp(data: any) {
+		return this._connection.post(this.registerApi(), data);
+	}
+	/**
+	 * Para registrar a un usuario mayorista.
+	 * @param data 
+	 * @returns 
+	 */
+	signUpWholesaler(data: any) {
+		return this._connection.post(this.registerWholesalerApi(),data);
+	}
+	/**
+	 * Chequea si un usuario esta habilitado a comprar o no.
+	 * @returns 
+	 */
+	isAbleToBuy():boolean {
+		const currentUser = this.getUserProfileAsUser() as User;
+		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(): User {
+        return this._user! as 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 */
+    private forceChannelsForSeller(tokens:any){
+        if (UserRoleType.SELLER == tokens.type as UserRoleType)
+            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 
+     */
+	 public setCustomer(customer:any){
+        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){
+                !localStorage.getItem(this.CHANNELSELLER) ?
+                    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
+                }
+                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.
+     */
+    private sameChannel = (channel:string, locale:string):boolean => (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.
+     */
+    private changeChannel = (channelConfig:any) => {
+        this._constants.modifyChannelConfig({
+            channel: channelConfig.channel,
+            locale: channelConfig.locale
+        })
+    }
+}

package/projects/ng-easycommerce/src/lib/ec-services/auth.storage.service.ts

@@ -0,0 +1,54 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, map } from 'rxjs';
+import { NgxLocalStorageService } from './ngx-local-storage.service';
+import { LocalStorageService } from './local-storage.service';
+import moment from 'moment';
+
+@Injectable({
+	providedIn: 'root'
+})
+export class AuthStorageService {
+	private _localStorage = inject(LocalStorageService);
+
+	private _authTokenSubject = new BehaviorSubject<string | null>(null)
+
+	// Contantes para el storage.
+	private readonly JWT_TOKEN = 'JWT_TOKEN'
+	private readonly REFRESH_TOKEN = 'REFRESH_TOKEN'
+	private readonly EXPIRATES_IN = 'EXPIRATES_IN'
+	constructor() { }
+
+	setAuthToken(token: string | null): void {
+		this._authTokenSubject.next(token);
+	}
+
+	getAuthToken$() {
+		return this._authTokenSubject.asObservable();
+	}
+
+	getAuthToken(): string | null {
+		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 
+	 */
+	private isTokenExpired() {
+		const fecha_expiracion = this.getExpiratesAt();
+		const result = moment() >= moment(fecha_expiracion);
+		return result;
+	}
+	/**
+	 * Obtiene la fecha de expiración del token.
+	 * @returns 
+	 */
+	private getExpiratesAt() {
+		return this._localStorage.getItem(this.EXPIRATES_IN);
+	}
+}

package/projects/ng-easycommerce/src/lib/ec-services/blocks-repository.service.ts

@@ -0,0 +1,67 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService } from '../constants';
+import { BehaviorSubject, map, Observable, shareReplay } from 'rxjs';
+import { IBlock, IBlockInfo } from '../interfaces';
+import { ConnectionService } from '../api';
+/**
+ * Servicio que maneja los bloques como repositorio.
+ * @class BlocksRepositoryService
+ */
+@Injectable({
+	providedIn: 'root'
+})
+export class BlocksRepositoryService {
+	/**
+	 * Constantes de la API
+	 */
+	private apiConstants = inject(ApiConstantsService);
+	/**
+	 * Menaja las conexiones con la API
+	 */
+	private connection = inject(ConnectionService)
+	/**
+	 * Subject para manejar los bloques recibidos.
+	 */
+	private blocksSubject = new BehaviorSubject<IBlock[]>([])
+	/**
+	 * Observable de bloques.
+	 */
+	private blocks$: Observable<IBlock[]> = this.blocksSubject.asObservable();
+
+	//API URLS
+	/**
+	 * Devuelve la url para obtener los bloques segun la sección.
+	 * @param section 
+	 * @returns 
+	 */
+	blocksAPI(section: string) { 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.
+	 */
+	public getBlocks(section: string): Observable<IBlock[]> {
+		//if(this.blocksSubject.getValue() != null){
+		this.connection.get(this.blocksAPI(section)).pipe(
+			shareReplay(1),
+			map((response: any) => {
+				//console.log(response)
+				this.blocksSubject.next(response.items)
+				return response
+			})
+		).subscribe()
+		//}
+		return this.blocks$
+	}
+
+	/* private hasSectionBlocks = (section: string) => {
+		
+	} */
+
+	private appendBlock = (blocks: IBlock[], section: string) => {
+		const new_block: IBlockInfo = { section, blocks };
+
+	}
+
+}

package/projects/ng-easycommerce/src/lib/ec-services/blocks.service.ts

@@ -0,0 +1,48 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ApiConstantsService } from '../constants';
+import { BlocksRepositoryService } from './blocks-repository.service';
+import { IBlock } from '../interfaces';
+/**
+ * Servicio de tipo adapter para manejar los bloques.
+ * @class BlocksService
+ */
+@Injectable({
+	providedIn: 'root'
+})
+export class BlocksService {
+	/**
+	 * Constantes de la API
+	 */
+	private apiConstants = inject(ApiConstantsService);
+	/**
+	 * Servicio de BlocksRepository.
+	 */
+	private blocksRepositoryService = inject(BlocksRepositoryService);
+	/**
+	 * Subject para manejar los bloques recibidos.
+	 */
+	private blocksSubject = new BehaviorSubject<any[]>([]);
+	/**
+	 * Observable de bloques.
+	 */
+	public blocks$: Observable<any[]> = this.blocksSubject.asObservable();
+
+	//API URLS
+	/**
+	 * Devuelve la url para interactuar con el bloque de contacto.
+	 * @returns 
+	 */
+	contactFormResponseAPI() { return `${this.apiConstants.CMS_URL}${this.apiConstants.LOCALE}/contact-form/response` }
+
+	//METHODS
+	/**
+	 * Obtiene los bloques de una sección en especifico.
+	 * @param section 
+	 * @returns Observable de los bloques.
+	 */
+	public getBlocks(section: string): Observable<any> {
+		return this.blocksRepositoryService.getBlocks(section)
+	}
+	constructor() { }
+}