ng-easycommerce-v18 0.0.1

package/projects/ng-easycommerce/src/lib/classes/checkout/steps.ts

@@ -0,0 +1,37 @@
+import { IStep, StepState, StepType } from "../../interfaces/step";
+
+export class Step implements IStep {
+
+    public name;
+    public label:string = '';
+    public priority;
+    public type: StepType = null;
+    public data:any;
+    public state: StepState = 'pending';
+
+    constructor(name:any, priority:any, label:string, state?:StepState) {
+        this.name = name;
+        this.label = label;
+        this.state = state || 'pending';
+        this.priority = priority;
+    }
+
+    doing = () => {
+        this.data = null;
+        this.state = 'doing';
+    };
+
+    restart = () => {
+        this.data = null;
+        this.state = 'pending';
+    }
+
+    ready = (data:any) => {
+        this.data = data;
+        this.state = 'ready';
+    }
+
+    isPending = () => this.state == 'pending' || this.state == 'doing';
+
+    isReady = () => this.state == 'ready' && this.data;
+}

package/projects/ng-easycommerce/src/lib/classes/filters/attributes-filter.ts

@@ -0,0 +1,74 @@
+import { inject } from "@angular/core";
+import { OptionsService } from "../../ec-services";
+import { FilterElement, FilterType, IFilter } from "../../interfaces";
+import { Filter } from "./filter";
+
+export class AttributesFilter extends Filter {
+    private _optionsService: OptionsService = inject(OptionsService);
+
+    override data: FilterElement[] = [];
+    override multi: boolean = false;
+
+    constructor(initialValue?: any, options?:any) {
+        super();
+        if(options){
+            this.setContent(options, initialValue); 
+        }else{
+            this._optionsService.getAttributes().subscribe(
+                res => {
+                    //console.log(res);
+                    this.setContent(res, initialValue);
+                }
+            )
+        }
+    }
+
+    override type(): FilterType { return 'attributes'; }
+
+    override setContent(options: any, initialValue?: any): void {
+        const attributes = this._optionsService.generateMenu(options);
+        attributes.forEach((filter: any) => filter = this.createElement(filter, options, initialValue));
+        this.data = attributes;
+    }
+    override getContent(): FilterElement[] {
+        return this.data;
+    }
+    override toUrlParams(actual_url = '&attributeCodes=', sublist?:any, already?:any) {
+        let elements = sublist || this.data;
+        let aux_url = '';
+        elements.forEach((element: any) => {
+            if (element.type == 'sub') {
+                let result = this.toUrlParams('', element.children, (actual_url != '&attributeCodes=' && actual_url != ''))
+                if (!actual_url.includes(result)) actual_url += this.cleanResult(result);
+            } else if (element.selected) {
+                if (actual_url == '&attributeCodes=' && aux_url == '') {
+                    aux_url = element.code;
+                }
+                else {
+                    if (aux_url == '') aux_url = (already ? '<and>' : '') + element.code;
+                    else aux_url += ('<and>' + element.code);
+                }
+            }
+        })
+        //console.log(actual_url + aux_url);
+        return actual_url + aux_url;
+    };
+
+    cleanResult(text: string) { return text.replace('&attributeCodes=', '') };
+
+    override createElement(filter: any, original: any, initialValue?: any) {
+        if (filter.type == 'sub') {
+            filter.multi = false;
+            filter.shape = 'text';
+            filter.value = original.code;
+            filter.children = filter.children.map((child: any, i: number) =>{
+                return this.createElement(child, child.children, initialValue)
+            });
+        } else {
+            filter.value = original.code;
+            filter.multi = false;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+        }
+        return filter;
+    }
+}

package/projects/ng-easycommerce/src/lib/classes/filters/category-filter.ts

@@ -0,0 +1,57 @@
+import { inject } from "@angular/core";
+import { OptionsService } from "../../ec-services";
+import { FilterElement, FilterType, IFilter } from "../../interfaces";
+import { Filter } from "./filter";
+
+export class CategoryFilter extends Filter{
+    private _optionsService: OptionsService = inject(OptionsService);
+
+    override data: FilterElement[] = [];
+    override multi: boolean = false;
+
+    constructor(private initialValues?: any,) {
+        super();
+        this._optionsService.getCategories().subscribe(res => {
+            //console.log(res);
+            this.setContent(res, initialValues);
+        })
+    }
+
+    override type(): FilterType {
+        return 'categories';
+    }
+    override setContent(options: any, initialValue?: any): void {
+        const categories = this._optionsService.generateMenu(options);
+        categories.forEach((filter: any, i: number) => filter = this.createElement(filter, options[i], initialValue));
+        this.data = categories;
+    }
+    override getContent(): FilterElement[] {
+        throw new Error("Method not implemented.");
+    }
+    override toUrlParams(actual_url = '', sublist?: any): string {
+        let elements = sublist || this.data;
+        elements.forEach((element: any) => {
+            if (element.type == 'sub' && !element.selected) {
+                const result = this.toUrlParams('', element.children);
+                !actual_url.includes(result) ? actual_url += result : null;
+            } else if (element.selected) {
+                if (actual_url == '') actual_url = '&category=' + element.value;
+                else actual_url = element.value;
+            }
+        })
+        return actual_url;
+    }
+    override createElement(filter: any, original: any, initialValue?: any) {
+        if (filter.type == 'sub') {
+            filter.multi = false;
+            filter.shape = 'text';
+            filter.value = original.code;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+            filter.children = filter.children.map((child:any, i:number) => this.createElement(child, original.children[i], initialValue));
+        } else {
+            filter.value = original.code;
+            filter.selected = (initialValue && this.removeAccents(original.slug?.toLowerCase()) == this.removeAccents(initialValue?.toLowerCase()));
+        }
+        return filter
+    }
+}

package/projects/ng-easycommerce/src/lib/classes/filters/dynamics-filter.ts

@@ -0,0 +1,57 @@
+import { FilterElement, FilterType, IFilter } from "../../interfaces";
+import { Filter } from "./filter";
+
+export class DynamicsFilter extends Filter{
+    generated_url = '';
+    override data: FilterElement[] = [];
+    override multi: boolean = true;
+    
+    override type(): FilterType {
+        return 'dynamics';
+    }
+    override setContent(options: any): void {
+        options = options.map((option:any) => option = this.createElement(option));
+        this.data = options;
+    }
+    override getContent(): FilterElement[] {
+        throw new Error("Method not implemented.");
+    }
+    override toUrlParams = (actual_url = '&optionCodes=', sublist?:any, already?:any):string => {
+        let elements = sublist || this.data;
+        let aux_url = '';
+        elements.forEach((element:any) => {
+            if (element.type == 'sub') {
+                let result = this.toUrlParams('', element.children, (actual_url != '&optionCodes=' && actual_url != ''))
+                if (!actual_url.includes(result)) actual_url += this.cleanResult(result);
+            } else if (element.selected) {
+                if (actual_url == '&optionCodes=' && aux_url == '') {
+                    aux_url = element.value;
+                }
+                else {
+                    if (aux_url == '') aux_url = (already ? '<and>' : '') + element.value;
+                    else aux_url += ('<and>' + element.value);
+                }
+            }
+        })
+        return actual_url + aux_url;
+    };
+    
+    override createElement(option: any) {
+        option = {
+            title: option.label, useToFilter:option.useToFilter, type: 'sub', multi: false, code: option.code, shape: option.type, children: option.values.map((value:any) => {
+                return {
+                    title: value.code,
+                    description: value.name,
+                    code: (option.code + ' ' + value.name),
+                    type: 'child',
+                    value: value.code,
+                    selected: false,
+                    image: value.image
+                }
+            })
+        }
+        return option;
+    }
+
+    cleanResult(text:string) {return text.replace('&optionCodes=', '')};
+}

package/projects/ng-easycommerce/src/lib/classes/filters/filter-factory.ts

@@ -0,0 +1,23 @@
+import { FilterType, IFilter, PaginationSettings } from "../../interfaces";
+import { AttributesFilter } from "./attributes-filter";
+import { CategoryFilter } from "./category-filter";
+import { DynamicsFilter } from "./dynamics-filter";
+import { Filter } from "./filter";
+import { SortFilter } from "./sort-filter";
+
+export class FilterFactory {
+    public create(filterType: FilterType, productsFilter?: PaginationSettings): Filter {
+        switch (filterType) {
+            case 'categories':
+                return new CategoryFilter(productsFilter ? (productsFilter.type == 'categories' && productsFilter.value) : null);
+            case 'attributes':
+                return new AttributesFilter(productsFilter ? (productsFilter.type == 'attributes' && productsFilter.value) : null);
+            case 'dynamics':
+                return new DynamicsFilter();
+            case 'sort':
+                return new SortFilter();
+            default:
+                throw new Error("Not implemented")
+        }
+    }
+}

package/projects/ng-easycommerce/src/lib/classes/filters/filter.ts

@@ -0,0 +1,89 @@
+import { FilterElement, FilterType, IFilter } from "../../interfaces";
+
+export class Filter implements IFilter  {
+    
+    data: FilterElement[] = [];
+    multi: boolean = false;
+    
+    type(): FilterType {
+        throw new Error("Method not implemented.");
+    }
+    setContent(options: any): void {
+        throw new Error("Method not implemented.");
+    }
+    getContent(): FilterElement[] {
+        throw new Error("Method not implemented.");
+    }
+    toUrlParams(): string {
+        throw new Error("Method not implemented.");
+    }
+    createElement(filter: any, original: any, initialValue?: any) {
+        throw new Error("Method not implemented.");
+    }
+    removeAccents = (str:string) => {
+        return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    }
+
+    setSelected(element:any, value?:any){
+        //console.log(element, value);
+        ((element.multi != undefined) && !element.multi) ? this.cleanFilter(this.data, element) : null;
+        this.setSelectedValue(element, value);
+    }
+
+    cleanFilter = (data:any, element_to_change:any) => {
+        //console.log("cleanFilter");
+        element_to_change && data.forEach((element:any) => {
+            element_to_change != element ? element.selected = false : null;
+            (element.children && element.children.length > 0) && this.cleanFilter(element.children, element_to_change);
+        })
+    }
+
+    setSelectedValue(element:any, value?:any, sublist?:any, multi?:any){
+        let elements = sublist || this.data;
+        let index = elements.findIndex((subelement:any) => {
+            return (element.code || element) == subelement.code;
+        });
+        if (index >= 0) {
+            elements[index].selected = elements[index].selected ? false : true;
+            !multi && elements.forEach((child:any, i:number) => {
+                if (i != index) child.selected = false;
+            });
+            return {
+                elements,
+                founded: true
+            };
+        } else {
+            elements.some((elem:any) => elem.type == 'sub') && elements.some(
+                (filter:any) => {
+                    let founded = false;
+                    if (filter.type == 'sub') {
+                        const result = this.setSelectedValue(element, value, filter.children, filter.multi);
+                        if (result && result.founded) {
+                            filter.children = result.elements;
+                            founded = true;
+                        }
+                    }
+                    return founded;
+                }
+            )
+        }
+        return null;
+    };
+
+    getSelectedList = (): any => this.findSelected(this.data, []);
+
+    findSelected = (elements: any[], result:any) => {
+        let element = elements.find(elem => elem.selected);
+        if (element) {
+            result.push(element.code);
+            return result;
+        }
+        elements.forEach(elem => {
+            if (elem.children && elem.children.length) {
+                let new_result = this.findSelected(elem.children, result);
+                if (new_result) result = new_result;
+            }
+        })
+        return result;
+    }
+}

package/projects/ng-easycommerce/src/lib/classes/filters/index.ts

@@ -0,0 +1,6 @@
+export * from'./category-filter';
+export * from'./attributes-filter';
+export * from'./dynamics-filter';
+export * from'./sort-filter';
+export * from'./filter-factory';
+export * from'./filter';

package/projects/ng-easycommerce/src/lib/classes/filters/sort-filter.ts

@@ -0,0 +1,93 @@
+import { inject } from "@angular/core";
+import { CoreConstantsService } from "../../constants";
+import { FilterElement, FilterType, IFilter } from "../../interfaces";
+import { Filter } from "./filter";
+
+export class SortFilter extends Filter {
+    private _consts: CoreConstantsService = inject(CoreConstantsService);
+
+    override data: FilterElement[] = [];
+    override multi: boolean = true;
+
+    constructor(){
+        super();
+        this.setContent();
+    }
+
+    override type(): FilterType {
+        return 'sort'
+    }
+    override setContent(): void {
+        this.data = [
+            {
+                title: 'price', type: 'sub', multi: false, code: 'price', shape: 'text', children: [
+                    { title: 'cheapest-first', code: 'price chip', type: 'child', value: 'asc', selected: false, multi: false, },
+                    { title: 'most-expensive-first', code: 'price expensive', type: 'child', value: 'desc', selected: false, multi: false, }
+                ]
+            },
+            {
+                title: 'alphabetical-order', type: 'sub', code: 'order-alph', multi: false, shape: 'text', children: [
+                    // { title: 'order-alph', type: 'child', code: 'alpha default', value: '', selected: false, multi: false },
+                    { title: 'ascendancy', type: 'child', code: 'alpha asc', value: 'asc', selected: false, multi: false, },
+                    { title: 'descendant', type: 'child', code: 'alpha desc', value: 'desc', selected: false, multi: false, }
+                ]
+            },
+            {
+                title: 'created-date',
+                type: 'sub',
+                code: 'recent',
+                multi: false,
+                shape: 'text',
+                children: [
+                    { title: 'order-date', type: 'child', code: 'recent default', value: '', selected: false, multi: false },
+                    { title: 'newest-first', type: 'child', code: 'recent desc', value: 'desc', selected: false, multi: false },
+                    { title: 'oldest-first', type: 'child', code: 'recent asc', value: 'asc', selected: false, multi: false },
+                ]
+            },
+            {
+                title: 'date-created',
+                type: 'sub',
+                code: 'update',
+                multi: false,
+                shape: 'text',
+                children: [
+                    { noUrl: true, title: 'newest-first', type: 'child', code: 'update asc', value: 'asc', selected: false, multi: false },
+                    { noUrl: true, title: 'oldest-first', type: 'child', code: 'update desc', value: 'desc', selected: false, multi: false },
+                ]
+            }
+        ]
+
+        if (!this._consts.getSortFilters().includes('all')) {
+            this.data = this.data.filter(elem => this._consts.getSortFilters().includes(elem.code))
+        }
+    }
+    override getContent(): FilterElement[] {
+        return this.data;
+    }
+    override toUrlParams(actual_url = '', sublist?:any, father?:any): string {
+        let elements = sublist || this.data;
+        elements.forEach((element:any) => {
+            if (!element.noUrl) { //Si es sin url, no se hace nada. Osea el filtrado es en la vista.
+                if (element.type == 'sub') {
+                    const result = this.toUrlParams(actual_url, element.children, element.title);
+                    !actual_url.includes(result) ? actual_url += result : null;
+                } else if (element.selected) {
+                    actual_url = ('&sorting[' + this.translate(father) + ']=' + element.value);
+                }
+            }
+        })
+        return actual_url;
+    }
+    override createElement(filter: any, original: any, initialValue?: any) {
+        throw new Error("Method not implemented.");
+    }
+
+    translate(value:string):string | null{
+        switch (value) {
+            case 'price': return 'price';
+            case 'created-date': return 'dateCreate';
+            case 'alphabetical-order': return 'name';
+            default: return null;
+        }
+    }
+}

package/projects/ng-easycommerce/src/lib/classes/index.ts

@@ -0,0 +1,3 @@
+export * from './user';
+export * from './filters';
+export * from './checkout';

package/projects/ng-easycommerce/src/lib/classes/user.ts

@@ -0,0 +1,68 @@
+import { Deserializable } from "../interfaces";
+
+export class User implements Deserializable {
+
+    private readonly USER = 'USER';
+    public type = 'loguedin';
+    public config = {};
+    public client_id = 'demo_client';
+    public client_secret = 'secret_demo_client';
+    public grant_type = 'password';
+    public email = '';
+    public username = '';
+    public password = '';
+    public first_name = '';
+    public last_name = '';
+    public address = { country: '', city: '', state: '', address: '', postcode: '' };
+    public birthday = '';
+    public gender = '';
+    public phone_number = '';
+    public suscribed_to_newsletter: boolean = true;
+    public document_type? = '';
+    public preferred_card? = '';
+    public document_number? = '';
+    public channels = []
+    public customers = []
+    public token = '';
+    public typeUser? = null;
+
+    initilized(res: any) {
+        this.token = res.token
+        this.typeUser = res.hasOwnProperty('type') ? res.type : 'retail_customer'
+        this.username = res.username
+        this.email = res.username
+        this.channels = res.channels || []
+        this.customers = res.customers || []
+    }
+
+    deserialize(input: any): this {
+        return Object.assign(this, input);
+    }
+
+    jsonify() {
+        return {
+            client_id: this.client_id,
+            client_secret: this.client_secret,
+            grant_type: this.grant_type,
+            username: this.username,
+            email: this.email,
+            password: this.password,
+            token: this.token,
+            typeUser: this.typeUser,
+            channels: this.channels,
+            customers: this.customers
+        }
+    }
+
+    public isSeller() { return this.typeUser && this.typeUser == 'seller' || false }
+
+    public setChannels(...channels: any): void { this.channels = channels }
+
+    public isWholesaler():boolean {
+		return  this.typeUser && (this.typeUser == 'wholesaler_customer' || this.typeUser == 'seller') || false
+	}
+
+    static fromJson(data: any): User {
+        return Object.assign(new User(), data);
+    }
+}

package/projects/ng-easycommerce/src/lib/constants/api.constants.service.ts

@@ -0,0 +1,69 @@
+import { inject, Injectable } from '@angular/core';
+import { ENVIRONMENT_TOKEN } from '../providers';
+import { Environment } from '../interfaces';
+import { LocalStorageService } from '../ec-services';
+import { TranslateService } from '@ngx-translate/core';
+import { CoreConstantsService } from './core.constants.service';
+
+/**
+ * Servicio que provee de datos que estan relacionado con las peticiones a la API
+ * @export
+ * @class ApiConstantsService
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class ApiConstantsService {
+	private _localStorage: LocalStorageService = inject(LocalStorageService);
+	private _translate: TranslateService = inject(TranslateService);
+
+	/**
+	 * Contiene los datos provisto por el frontend en el archivo environment.ts
+	 */
+	private environment:Environment = inject(ENVIRONMENT_TOKEN)
+	/**
+	 * Canal actual del frontend
+	 */
+	public CHANNEL:string = this.environment.channel;
+	/**
+	 * Locale actual del frontend
+	 */
+	public LOCALE:string = this.environment.locale;
+	/**
+	 * URL del backend para realizar las peticiones
+	 */
+	public readonly API_URL:string = this.environment.apiUrl;
+	/**
+	 * URL para las peticiones a shop-api
+	 */
+	public readonly SHOP_API_URL:string = 'shop-api/';
+	/**
+	 * URL para las peticiones a cms
+	 */
+	public readonly CMS_URL:string = 'cms/';
+	/**
+	 * URL base para realizar las peticiones a la API
+	 */
+	private urlBase: string = this.environment.apiUrl
+	/**
+	 * Retorna la url base
+	 * @returns {string}
+	 */
+	public getUrlBase(): string { return this.urlBase}; 
+	/**
+	 * Cambia el canal actual
+	 * @param code
+	 * @returns 
+	 */
+	public setChannel(code: string):void{ this.CHANNEL = code;} 
+
+	public setLocale(locale: string):void{
+		this._localStorage.setItem(this.LOCALE_KEY, locale);
+		this._translate.use(locale.split('_')[0])
+		this.LOCALE = locale;
+	}
+
+	//Storage key
+	private readonly LOCALE_KEY:string = 'LOCALE';
+	private readonly CHANNEL_KEY:string = 'CHANNEL';
+}