ng-easycommerce-v18 0.0.1

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

@@ -0,0 +1,492 @@
+import { inject, Injectable } from '@angular/core';
+import { BalanceCustomer, CartItem, ICoupon, Product } from '../interfaces';
+import { AuthService } from './auth.service';
+import { ToastService } from './toast.service';
+import { ConnectionService } from '../api';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { BehaviorSubject, combineLatest, firstValueFrom, map, Observable } from 'rxjs';
+import { AnalyticsService } from './analytics';
+import { LocalStorageService } from './local-storage.service';
+import { ChannelService } from './channel.service';
+import { NgxLocalStorageService } from './ngx-local-storage.service';
+@Injectable({
+	providedIn: 'root'
+})
+export class CartService {
+	private _authService: AuthService = inject(AuthService);
+	private _toastService: ToastService = inject(ToastService);
+	private _connection: ConnectionService = inject(ConnectionService);
+	private _apiConsts: ApiConstantsService = inject(ApiConstantsService);
+	private _analyticsService: AnalyticsService = inject(AnalyticsService);
+	private _localStorage: LocalStorageService = inject(LocalStorageService);
+	private _channelService: ChannelService = inject(ChannelService);
+	private _consts: CoreConstantsService = inject(CoreConstantsService);
+	private _storage: NgxLocalStorageService = inject(NgxLocalStorageService);
+
+	private _cartSubject: BehaviorSubject<any> = new BehaviorSubject(null);
+	private _promotionsSubject: BehaviorSubject<any> = new BehaviorSubject([]);
+	private _couponSubject: BehaviorSubject<any> = new BehaviorSubject(null);
+	private _cartItemsSubject: BehaviorSubject<CartItem[]> = new BehaviorSubject<CartItem[]>([])
+	private _requestInProcess: BehaviorSubject<boolean> = new BehaviorSubject(false);
+	private _balanceCustomerSubject: BehaviorSubject<BalanceCustomer> = new BehaviorSubject<BalanceCustomer>({
+        allowAnyPaymentMethod: false,
+        allowExceedBalance: false,
+        creditAmount: 0,
+        showMax: false,
+        showPrice: false,
+        remainingCredits: 0,
+    });
+
+	private readonly CART_KEY: string = 'cart';
+	private readonly CART_TOKEN_KEY: string = 'cart_token';
+
+	private _items: any[] = [];
+	private _count: number = 0;
+	public cartToken: string | null = '';
+	public channelConfig: any = {};
+	private _locale = "";
+	public cartItems$ = this._cartItemsSubject.asObservable().pipe(map(items => this.switchPriceInCartItem(items)))
+	public coupon$: Observable<any> = this._couponSubject.asObservable();
+	public cart$: Observable<any> = this._cartSubject.asObservable();
+	public loading$: Observable<boolean> = this._requestInProcess.asObservable();
+	private _haveToUpdate = true;
+
+	//API URL
+	private _cartBaseUrl: string = `${this._apiConsts.SHOP_API_URL}${this._apiConsts.CHANNEL}/carts`;
+
+	public updateItemQuantityApi(item_id: any) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }
+	public addItemApi(): string { return this._cartBaseUrl + '/' + this.cartToken + '/items?locale=' + this._apiConsts.LOCALE }
+	public cartItemsApi(): string { return this._cartBaseUrl + '?locale=' + this._apiConsts.LOCALE }
+	public deleteItemApi(item_id: string) { return this._cartBaseUrl + '/' + this.cartToken + '/items/' + item_id + '?locale=' + this._apiConsts.LOCALE; }
+	public couponApi() { return this._cartBaseUrl + '/' + this.cartToken + '/coupon' };
+
+	constructor() {
+		this._requestInProcess.next(true);
+		this.cartToken = this._localStorage.getItem(this.CART_TOKEN_KEY) || null;
+		this.initializeDataCart();
+		this._channelService.channel$.subscribe(res => this.channelConfig = res)
+	}
+	/**
+	 * Inicializa el carrito con los datos del local storage en caso de que existan o no.
+	 */
+	private initializeDataCart() {
+		combineLatest([this._authService.loggedIn$, this._storage.getItem(this.CART_KEY)]).subscribe({
+			next: ([loggedIn, token]) => {
+				//console.log(loggedIn, token);
+				this._items = token || [];
+				this.getCart()
+			}
+		})
+	}
+	/**
+	 * Obtiene el carrito desde el backend y lo inicializa. 
+	 * Si existe el cartToken y hay items en el carrito, envía el token como parámetro.
+	 */
+	private getCart() {
+		//console.warn(this._items, this._items.length, this.cartToken)
+		firstValueFrom(
+			this._connection.post(this.cartItemsApi(), ((this.cartToken && this._items.length >= 1) && { token: this.cartToken }))
+		).then((res: any) => {
+			//console.log(res)	
+			this.initializeCart(res)
+		})
+	}
+	/**
+	 * Configura el carrito con los parametros iniciales.
+	 * @param response 
+	 * @returns 
+	 */
+	initializeCart(response: any): any {
+		this.cartToken = response.tokenValue;
+		this._localStorage.setItem(this.CART_TOKEN_KEY, this.cartToken);
+		this._locale = response.locale;
+
+		this.updateCartObj(response, false);
+		this.updateCartItems(this.transformItems(response.items));
+		this._requestInProcess.next(false);
+		return true;
+	}
+	/**
+	 * Actualiza los items del carrito.
+	 * @param items 
+	 */
+	updateCartItems(items: any[]) {
+		this._items = items;
+		this._count = items.length;
+		this._cartItemsSubject.next(this._items);
+		this.updateLocalCart();
+		this._requestInProcess.next(false);
+	}
+	/**
+	 * Agrega un producto al carrito con la cantidad deseada. 
+	 * @param product Producto a agregar
+	 * @param quantity Cantidad 
+	 * @param variantId Id de la variante
+	 * @returns 
+	 */
+	addToCart(product: Product, quantity: number, variantId: string) {
+		//console.log(product);
+		if (!this._authService.isAbleToBuy()) {
+			this._toastService.show('must-select-customer')
+			return
+		}
+		this._requestInProcess.next(true);
+		let added = this.addIfAllreadyExists(product, variantId, quantity);
+
+		if (!added) {
+			firstValueFrom(
+				this._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variantId }))
+				.then(
+					res => {
+						// Manejar la respuesta HTTP exitosa (código 200)
+						this.appendToCart(res);
+						this._toastService.show('product-added');
+					},
+					err => {
+						// Manejar el error de la llamada HTTP (código 500 u otro error)
+						if (err.status === 500) {
+							// Código de error 500 (timeout)
+							this.handleError(err);
+							this._toastService.show('cart-error');
+						} else {
+							// Otro código de error
+							this.handleError(err);
+							this._toastService.show('error-server');
+						}
+					}
+				);
+		}
+	}
+	/**
+	 * Actualiza el carrito agregando los nuevos items.
+	 * @param cart 
+	 */
+	appendToCart(cart: any) {
+		this.updateCartObj(cart);
+		this._items = this.transformItems(cart.items);
+		this._count = this._items.length;
+		this._requestInProcess.next(false);
+		this.updateLocalCart();
+		this._cartItemsSubject.next(this._items);
+	}
+	/**
+	 * Mapea los items del carrito para darle un mejor formato similar a la interfaz `CartItem`.
+	 * @param items 
+	 * @returns 
+	 */
+	transformItems(items: any): any[] {
+		return items.map((item: any) => {
+			return {
+				product: item.product,
+				variant_id: item.product.variants[0].code,
+				lot: item.orderItemLot,
+				quantity: item.quantity,
+				item_id: item.id,
+				total: item.total
+			}
+		});
+	}
+	/**
+	 * Chequea si el producto ya existe en el carrito de compras.
+	 * @param product 
+	 * @param variantId 
+	 * @param quantityAdd Cantidad a agregar. Por defecto es 1.
+	 */
+	addIfAllreadyExists(product: Product, variantId: string, quantityAdd: number = 1) {
+		return this._items.find((item: any, index) => {
+			if (item.product.id == product.id && item.variant_id == variantId) {
+				this.updateItemQuantity(item, this.findItem(product.id).quantity + quantityAdd);
+				return true;
+			}
+			return false;
+		})
+	}
+	/**
+	 * Obtiene la cantidad de un producto del item del carrito 
+	 * @param codeVariant codigo de la variante.
+	 * @returns la cantidad o `0` en su defecto.
+	 */
+	getCountFromItemInCart(codeVariant: any): number {
+		return this._items.find(item => item.variant_id == codeVariant)?.quantity || 0;
+	}
+	/**
+	 * Obtiene un observable con la cantidad de items en el carrito.
+	 */
+	getCountCartItems(): Observable<number> {
+		return this.cartItems$.pipe(map((cartItems) => cartItems?.length));
+	}
+	/**
+	 * Mapea los productos en el carrito para cambiar el precio obteniendo de la variante y seleccionando si es
+	 * precio de oferta o el precio normal.
+	 * @param items 
+	 * @returns 
+	 */
+	private switchPriceInCartItem = (items: any[]) => {
+		return items.map(
+			item => {
+				if (item.product) {
+					item.product.price = item.product.variants[0].saleprice ? item.product.variants[0].saleprice : item.product.variants[0].price;
+				}
+				return item
+			}
+		)
+	}
+	/**
+	 * Actualiza la cantidad de un producto existente en el carrito.
+	 * @param item el item a actualizar.
+	 * @param quantity la cantidad nueva.
+	 */
+	updateItemQuantity(item: CartItem, quantity: number) {
+		if (this.validateQuantity(item, quantity)) {
+			firstValueFrom(
+				this._connection.put(this.updateItemQuantityApi(this.findItemByIdVariant(item.variant_id)), { 'quantity': Number(quantity) })).then(
+					res => this.updateCartObj(res) && this.updateCartItemQuantity(item.variant_id, Number(quantity)),
+					err => this.handleError(err)
+				)
+		}
+	}
+	/**
+	 * Maneja el error en caso de que no se pueda agregar al carrito el producto.
+	 * @param err 
+	 */
+	handleError(err: any): void {
+		this._toastService.show('operation-error-param');
+		this._requestInProcess.next(false);
+	}
+	/**
+	 * Actualiza la cantidad del item del producto del carrito.
+	 * @param variantId ID de la variante para buscar el item.
+	 * @param quantity Nueva cantidad. 
+	 */
+	updateCartItemQuantity(variantId: any, quantity: number): void {
+		//console.log("updateCartItemQuantity", this._items, variantId)
+		let newQuantity = this._items.find(item => item.variant_id == variantId).quantity = quantity;
+		this._cartItemsSubject.next(this._items);
+		this._requestInProcess.next(false);
+		this.updateLocalCart();
+		this._toastService.show('product-updated', { quantity: newQuantity });
+	}
+	/**
+	 * Actualiza los datos del carrito en el localStorage. 
+	 */
+	updateLocalCart() {
+		this._storage.setItem(this.CART_KEY, this._items)
+	}
+	/**
+	 * Actualiza el carrito. Emite evento de analitics. 
+	 * Actualiza todo lo relacionado al cupón.
+	 * @param cart Respuesta producida por el enpoint con información del carrito.
+	 * @param emitEvent 
+	 * @returns 
+	 */
+	updateCartObj(cart: any, emitEvent = true): boolean {
+		this._cartSubject.next(cart);
+		emitEvent && this._analyticsService.callEvent('add_to_cart', cart);
+		//this._promotionsSubject.next(this.orderUtils.getPromotions(cart, true));
+
+		cart.couponCode
+			? this.formatCoupon(cart)
+			: this._couponSubject.next(null);
+		return true;
+	}
+	/**
+	 * Aplicar un mejor formato a los datos de los cupones aplicados.
+	 * @param cart 
+	 */
+	formatCoupon(cart: any) {
+		let current_coupon = this._couponSubject.value;
+		let coupon: ICoupon = { code: cart.couponCode };
+		try {
+			const key = Object.keys(cart.cartDiscounts)[0];
+			coupon = {
+				...coupon,
+				amount: (cart.cartDiscounts && cart.cartDiscounts[key].amount.current) || 0,
+				name: (cart.cartDiscounts && cart.cartDiscounts[key].name) || 'no-name'
+			};
+		} catch (e) { }
+		(coupon != current_coupon) && this._couponSubject.next(coupon);
+		//console.log(coupon);
+	}
+	/**
+	 * Retorna el ID del item del carrito.
+	 * @param variant_id Id de la variante utilizada para buscar el item.
+	 * @returns 
+	 */
+	findItemByIdVariant(variant_id: any): any {
+		return this._items.find(item => item.variant_id == variant_id)!.item_id
+	}
+	/**
+	 * Valida la cantidad para saber si se puede actualizar o no.
+	 * @param item item del carrito
+	 * @param quantity cantidad a agregar
+	 * @returns 
+	 */
+	validateQuantity(item: any, quantity: any) {
+		if ((this.getCountFromItemInCart(item.productCode) + quantity) > item.product.variants[0].maximumItemsQuantity) {
+			this._toastService.show('maximum-items-quantity', { quantity: item.product.variants[0].maximumItemsQuantity })
+			return false
+		}
+		if ((this.getCountFromItemInCart(item.productCode) + quantity) < item.product.variants[0].minimumItemsQuantity) {
+			this._toastService.show('minimum-items-quantity', { quantity: item.product.variants[0].minimumItemsQuantity })
+			return false
+		}
+		return true
+	}
+	/**
+	 * Busca un producto a través de su ID en los items del carrito.
+	 * @param product_id 
+	 * @returns
+	 */
+	findItem(product_id: any): any { return this._items.find((item: any) => item.product.id == product_id) }
+	/**
+	 * Elimina un item del carrito en el backend.
+	 * @param item item a eliminar
+	 * @param toast indica si se dispara un toast  o no. Por defecto en `true`.
+	 */
+	deleteCartItem(item: any, toast: boolean = true) {
+		let idItemSearched = this.findItemByIdVariant(item.variant_id)
+		//console.log(idItemSearched)
+		this._requestInProcess.next(true);
+		firstValueFrom(this._connection.delete(this.deleteItemApi(idItemSearched))).then(
+			res => {
+				this.removeCartItem(res, item, toast);
+				this._requestInProcess.next(false);
+			},
+			err => {
+				this.handleError(err);
+				this._requestInProcess.next(false);
+			}
+		)
+	}
+	/**
+	 * Elimina un item en carrito de forma local. 
+	 * @param cart Carrito, es decir, respuesta del backend.
+	 * @param product producto a eliminar
+	 * @param toast {boolean} para indicar si se dispara un toast o no. 
+	 */
+	removeCartItem(cart: any, product: any, toast: boolean) {
+		this.updateCartObj(cart, false);
+		this._items.splice(this._items.findIndex(value => value.item_id === product.item_id), 1);
+		this._cartItemsSubject.next(this._items);
+		toast && this._requestInProcess.next(false);
+		toast && this._toastService.show('product-removed');
+		this.updateLocalCart();
+		this._analyticsService.callEvent('remove_from_cart', { ...product, currency: this._consts.currency.code })
+	}
+	/**
+	 * Agrega un cupon al carrito.
+	 * @param value Codigo del cupón.
+	 */
+	addCoupon(value: string) {
+		firstValueFrom(this._connection.put(this.couponApi(), { coupon: value })).then(
+			res => {
+				//console.log(res)
+				this.updateCartObj(res)
+				this._toastService.show('Cupon aplicado')
+			},
+			err => {
+				//console.error(err) 
+				this._toastService.show('invalid-coupon')
+			}
+		)
+	}
+	/**
+	 * Elimina un cupón del carrito. 
+	 */
+	removeCoupon() {
+		firstValueFrom(this._connection.delete(this.couponApi())).then(
+			res => {
+				//console.log(res)
+				this.updateCartObj(res)
+			}
+		)
+	}
+	/**
+	 * Retorna un observable con el subtotal del carrito.
+	 * @returns 
+	 */
+	getSubTotalAmount(): Observable<number> {
+		return this.cart$.pipe(map((cart) => cart?.totals?.items));
+	}
+	/**
+	 * Retorna un observable con el total del monto de las promociones aplicadas.
+	 * @returns 
+	 */
+	getTotalPromotionAmount(): Observable<number> {
+		return this.cart$.pipe(map((cart) => cart?.totals?.promotion));
+	}
+	/**
+	 * Retorna un observable con el monto de los impuestos aplicados.
+	 * @returns 
+	 */
+	getTaxesAmount(): Observable<number> {
+		return this.cart$.pipe(map((cart) => cart?.totals?.taxes > 0 ? cart?.totals?.taxes : 0));
+	}
+	/**
+	 * Retorna un observable con el monto total del carrito.
+	 * @returns 
+	 */
+	getTotalAmount() {
+		return this.cart$.pipe(map((cart) => cart?.totals?.total));
+	}
+	/**
+	 * Retorna el token del carrito.
+	 * @returns 
+	 */
+	getCartToken() {
+		return this.cartToken;
+	}
+	changeHaveToUpdate = (value: any) => this._haveToUpdate = value;
+	clearAndResetCustomerCart() {
+		console.log("Clearing and reseting...")
+		this.resetCart(this.getCartByCustomer)
+	}
+
+	private getCartByCustomer = async () =>
+		this._connection.post(this.cartItemsApi()).subscribe(
+			res => this.initializeCart(res)
+		)
+	private resetCart = (fn?: any) => {
+		this._items = [];
+		this._cartSubject.next(null);
+		this.updateBalanceAttributes(null);
+		this.cartToken = null;
+		this._cartItemsSubject.next([]);
+		this._count = 0;
+		this._localStorage.setItem(this.CART_KEY, "[]");
+		this._localStorage.removeItem(this.CART_TOKEN_KEY);
+		fn && fn();
+	}
+	clearAndResetCart() {
+        this.resetCart(() => this.getCart);
+    }
+
+	public updateBalanceAttributes(cartData: any) {
+        const balanceData = {
+            allowAnyPaymentMethod: cartData?.allowAnyPaymentMethod ?? false,
+            allowExceedBalance: cartData?.allowExceedBalance ?? false,
+            creditAmount: cartData?.creditAmount ?? null,
+            showMax: cartData?.showMax ?? false,
+            showPrice: cartData?.showPrice ?? false,
+            remainingCredits: cartData?.creditAmount && cartData?.creditAmount >= cartData?.totals.total
+                ? cartData?.creditAmount - cartData?.totals.total
+                : 0,
+        };
+
+        this._balanceCustomerSubject.next(balanceData);
+		console.log(balanceData)
+    }
+	addToLot(product: Product, quantity: number, variant_id: any, id?: number, order_item_id?: any, lot_quantity?: any, unit_price?: any, unit_total?: any, ajustement_total?: any, total_lot?: number, lot_status?: string, date_request?: string, notes?: string, shipping_address_id?: number, shipping_address_name?: string, action?: string){
+        if (!this._authService.isAbleToBuy()) {
+            this._toastService.show('must-select-customer')
+            return
+        }
+
+        let added = '';
+        !added && this._connection.post(this.addItemApi(), { productCode: product.id, quantity: quantity, variantCode: variant_id, id: id || '', order_item_id: order_item_id || '', lot_quantity: lot_quantity || '', unit_price: unit_price || '', unit_total: unit_total || '', ajustement_total: ajustement_total || '', total_lot: total_lot || '', lot_status: lot_status || '', date_request: date_request || '', notes: notes || '', shipping_address_id: shipping_address_id || '', shipping_address_name: shipping_address_name || '', action: action || 'newlot' })
+            .subscribe({
+				next: (res) => this.appendToCart(res),
+				error: (err) => this.handleError(err)
+			});
+    }
+}

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

@@ -0,0 +1,81 @@
+import { inject, Injectable } from '@angular/core';
+import { ApiConstantsService, CoreConstantsService } from '../constants';
+import { ConnectionService } from '../api';
+import { map, Observable, ReplaySubject, shareReplay } from 'rxjs';
+/**
+ * Servicio para manejar los canales de la aplicación
+ * @class ChannelService
+ */
+@Injectable({
+	providedIn: 'root'
+})
+export class ChannelService {
+	/**
+	 * Constantes de la API
+	 */
+	private apiConsts: ApiConstantsService = inject(ApiConstantsService);
+	/**
+	 * Constantes del core
+	 */
+	private consts: CoreConstantsService = inject(CoreConstantsService)
+	/**
+	 * Maneja las peticiones a la API
+	 */
+	private connection: ConnectionService = inject(ConnectionService)
+	/**
+	 * Subject para manejar los cambios en los canales.
+	 */
+	private channelSubject = new ReplaySubject<any>()
+	/**
+	 * Observable de canales.
+	 */
+	public channel$: Observable<any> = this.channelSubject.asObservable()
+	/**
+	 * Almacena el canal activo en la aplicación.
+	 */
+	public activeChannel: any;
+	/**
+	 * Almacena el tipo de canal.
+	 */
+	public channelType: any;
+
+	//API URL
+	/**
+	 * Devuelve la url para obtener los datos de un canal.
+	 * @returns 
+	 */
+	private channelApi() { return `${this.apiConsts.SHOP_API_URL}${this.apiConsts.CHANNEL}/channel`; }
+
+	constructor() { }
+	/**
+	 * Obtiene el canal de la API
+	 * @returns Observable con el canal.
+	 */
+	public getChannel = (): Observable<any> => {
+		this.connection.get(this.channelApi()).pipe(
+			shareReplay(1),
+			map((response: any) => {
+				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 
+	 */
+	public setChannelInfo(channelObj: any) {
+		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 
+	 */
+	public getActiveChannel() { return this.activeChannel; }
+}