@jvsoft/utils 0.0.13-alpha.2 → 0.0.13-alpha.4

package/src/functions/forms.ts

@@ -0,0 +1,251 @@
+import {AbstractControl, FormArray, FormControl, FormGroup, ValidationErrors, Validators} from '@angular/forms';
+import {ReactiveFormConfig} from '@rxweb/reactive-form-validators';
+import moment from "moment";
+import {BehaviorSubject} from 'rxjs';
+
+export function establecerQuitarRequired(formulario: FormGroup, establecer: any[] = [], quitar: any[] = [], camposDisabled: string[] | 'todos' = []) {
+    establecer.forEach((control: string) => {
+        if (!formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.addValidators([Validators.required]);
+            formulario.get(control)?.enable();
+            formulario.get(control)?.updateValueAndValidity();
+        }
+    });
+    const deshabilitar = (strControl: string) => {
+        if (camposDisabled == 'todos') {
+            formulario.get(strControl)?.disable();
+            console.log(strControl);
+        }
+        else {
+            if (camposDisabled.includes(strControl)) {
+                formulario.get(strControl)?.disable();
+            }
+        }
+    }
+    quitar.forEach(control => {
+        if (formulario.get(control)?.hasValidator(Validators.required)) {
+            formulario.get(control)?.removeValidators([Validators.required]);
+            formulario.get(control)?.updateValueAndValidity();
+        }
+        deshabilitar(control);
+    });
+}
+
+export function getFormValidationErrors(form: FormGroup) {
+    const result: { control: string; error: string; value: any; }[] = [];
+    Object.keys(form.controls).forEach(key => {
+        const formProperty = form.get(key);
+        if (formProperty instanceof FormGroup) {
+            result.push(...getFormValidationErrors(formProperty));
+        }
+        const controlErrors: ValidationErrors | null | undefined = formProperty?.errors;
+        if (controlErrors) {
+            Object.keys(controlErrors).forEach(keyError => {
+                result.push({
+                    control: key,
+                    error: keyError,
+                    value: controlErrors[keyError]
+                });
+            });
+        }
+    });
+
+    return result;
+}
+
+export function mensajesErrorFormControl(control: AbstractControl | null): string {
+    if (!control || !control.errors || !control.touched) return '';
+
+    ReactiveFormConfig.set({
+        // RxwebValidators
+        validationMessage: {
+            required: 'Es requerido',
+            numeric: 'Debe ser numérico valido',
+            // minLength: 'minimum length is {{1}}',
+            // maxLength: 'allowed max length is {{1}}',
+        },
+    });
+
+    const errorMessages: Record<string, string> = {
+        required: 'Es requerido',
+        numeric: 'Debe ser numérico válido',
+        min: `Valor mínimo permitido: ${control.errors['min']?.min}`,
+        minValue: 'Debe ser positivo',
+        minlength: `Mínimo ${control.errors['minlength']?.requiredLength} caracteres.`,
+        maxlength: `Caracteres ${control.errors['maxlength']?.actualLength}/${control.errors['maxlength']?.requiredLength}`,
+        email: 'No se cumple con el formato de Correo Electrónico',
+        isNumeric: 'Debe seleccionar una opción',
+        hasNumber: 'Se requiere al menos un número',
+        hasCapitalCase: 'Se requiere al menos una mayúscula',
+        hasSmallCase: 'Se requiere al menos una minúscula',
+        hasSpecialCharacters: 'Se requiere al menos un carácter especial',
+        NoPassswordMatch: 'La contraseña no coincide',
+        itemSelected: 'Debe seleccionar una opción de la lista',
+        inputMask: 'El formato ingresado no es válido',
+    };
+
+    // Devuelve el primer mensaje de error encontrado
+    for (const errorKey of Object.keys(control.errors)) {
+        if (errorMessages[errorKey]) {
+            return errorMessages[errorKey];
+        }
+    }
+
+    // Si el error tiene un mensaje personalizado, usarlo
+    return control.errors[Object.keys(control.errors)[0]]?.message || '';
+}
+
+export function toFormData<T extends Record<string, any>>(formValue: T): FormData {
+    const formData = new FormData();
+
+    Object.keys(formValue).forEach((key) => {
+        const value = formValue[key];
+
+        if (value === null || value === undefined) {
+            return; // Ignorar valores nulos o indefinidos
+        }
+
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                if (typeof item === 'object' && item !== null) {
+                    if ('file' in item) {
+                        formData.append(`${key}[${index}]`, item.file);
+                    }
+                    else {
+                        formData.append(`${key}[${index}]`, JSON.stringify(item));
+                    }
+                }
+                else {
+                    formData.append(`${key}[${index}]`, item.toString());
+                }
+            });
+        }
+        else if (typeof value === 'object') {
+            // Si es un objeto (pero no un array), convertirlo a JSON
+            formData.append(key, JSON.stringify(value));
+        }
+        else {
+            // Para valores primitivos (string, number, boolean)
+            formData.append(key, value.toString());
+        }
+    });
+
+    return formData;
+}
+
+export function markAsTouchedWithoutEmitEvent(control: AbstractControl): void {
+    if (control instanceof FormControl) {
+        control.markAsTouched({onlySelf: true});
+        control.updateValueAndValidity({emitEvent: false});
+    }
+    else if (control instanceof FormGroup || control instanceof FormArray) {
+        Object.values(control.controls).forEach(childControl => {
+            markAsTouchedWithoutEmitEvent(childControl);
+        });
+        control.updateValueAndValidity({emitEvent: false});
+    }
+}
+
+
+export interface SetControlDesdeListaConfig<T, V = any> {
+    lista$: BehaviorSubject<T[]>;
+    formControl?: FormControl<V>;
+    formGroup?: FormGroup;
+    controlName?: string;
+    idProp?: keyof T;
+    idValor?: any;
+    selector?: (item: T) => V;
+    usarPrimeraOpcion?: boolean; // ✅ nuevo
+}
+
+export function setControlDesdeLista<T, V = any>(
+    config: SetControlDesdeListaConfig<T, V>
+): void {
+    const lista = config.lista$?.getValue() ?? [];
+
+    if (!lista.length) return;
+
+    let seleccionado: T | undefined;
+
+    if (config.idProp && config.idValor !== undefined) {
+        seleccionado = lista.find((item: any) => item[config.idProp] === config.idValor);
+    } else if (config.usarPrimeraOpcion) {
+        seleccionado = lista[0];
+    }
+
+    console.log(seleccionado);
+    if (!seleccionado) return;
+
+    let valor: V;
+
+    if (config.selector) {
+        valor = config.selector(seleccionado);
+    } else if (config.idProp) {
+        valor = seleccionado[config.idProp] as V;
+    } else {
+        valor = seleccionado as unknown as V;
+    }
+
+    if (config.formControl) {
+        config.formControl.setValue(valor);
+    } else if (config.formGroup && config.controlName) {
+        const control = config.formGroup.get(config.controlName);
+        if (control instanceof FormControl) {
+            (control as FormControl<V>).setValue(valor);
+        }
+    }
+}
+
+
+export function transformarFechasPorNombreDeCampo<T extends Record<string, any>>(formValue: T): T {
+    const retData: any = {};
+
+    Object.entries(formValue).forEach(([key, value]) => {
+
+        // ✅ No procesar Blob o File
+        if (value instanceof Blob || value instanceof File) {
+            retData[key] = value;
+            return;
+        }
+
+        if (value instanceof Date) {
+            if (/^d[A-Za-z]+/.test(key)) {
+                retData[key] = moment(value).format('YYYY-MM-DD');
+            } else {
+                retData[key] = new Date(Date.UTC(
+                    value.getFullYear(),
+                    value.getMonth(),
+                    value.getDate(),
+                    value.getHours(),
+                    value.getMinutes(),
+                    value.getSeconds()
+                ));
+            }
+        } else if (/^dt[A-Za-z]+/.test(key) && typeof value === 'string') {
+            if (/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}\.\d{3}/.test(value)) {
+                retData[key] = new Date(value + 'Z');
+            } else if (/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(value) || /\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}/.test(value)) {
+                retData[key] = new Date(value + ':00.000Z');
+            } else {
+                console.warn('FECHA INVALIDA AL ENVIAR (FormInter):', key, value);
+                retData[key] = value;
+            }
+        } else if (Array.isArray(value)) {
+            if (value.every(v => v instanceof File || v instanceof Blob)) {
+                retData[key] = value;
+            } else {
+                retData[key] = value.map(item =>
+                    typeof item === 'object' && item !== null
+                        ? transformarFechasPorNombreDeCampo(item)
+                        : item
+                );
+            }
+        } else if (typeof value === 'object' && value !== null) {
+            retData[key] = transformarFechasPorNombreDeCampo(value);
+        } else {
+            retData[key] = value;
+        }
+    });
+
+    return retData;
+}

package/src/functions/http-client.ts

@@ -0,0 +1,110 @@
+import {HttpErrorResponse} from '@angular/common/http';
+import {mensajeAlerta, mensajeToast} from './sweetalert';
+
+export function mensajesDeError(error: HttpErrorResponse, toast = false) {
+    let msg;
+
+    if (error.error && error.error instanceof ArrayBuffer) {
+        const msgArrayBuffer = (arrayBuffer: ArrayBuffer): string => {
+            try {
+                const mensajeError = JSON.parse(new TextDecoder("utf-8").decode(arrayBuffer));
+                return mensajeError.message || 'Error desconocido';
+            } catch (parseError) {
+                console.error('Error al analizar la respuesta JSON:', parseError);
+                return 'Error al analizar la respuesta JSON';
+            }
+        }
+        msg = msgArrayBuffer(error.error);
+    }
+    else {
+
+        switch (error.status) {
+            case 0:
+                // msg = error.message;
+                msg = 'El servidor no responde, verifica tu conexion a la red';
+                console.log(error);
+                break;
+            case 401:
+                if (error.error && typeof error.error == 'object') {
+                    if (error.error.message) {
+                        msg = error.error.message;
+                    }
+                    else if (error.error.error) {
+                        msg = error.error.error;
+                    }
+                    else {
+                        msg = JSON.stringify(error.error);
+                        console.log(error);
+                    }
+                }
+                else if (error.error && typeof error.error == 'string') {
+                    msg = error.error;
+                }
+                else {
+                    msg = 'Acceso no autorizado';
+                    console.log(error);
+                }
+                break;
+            case 422:
+                let strEr = '';
+
+                console.log(typeof error.error.errors);
+                console.log(error.error.errors);
+                if (error.error.errors) {
+                    Object.keys(error.error.errors).forEach(o => {
+                        strEr += '<li>' + error.error.errors[o][0] + '</li>';
+                    });
+                    msg = (error.error.message ?? '') + '<ul>' + strEr + '</ul>';
+                }
+                else if (error.error.error) {
+                    msg = error.error.msg;
+                }
+                break;
+            case 429:
+            case 400:
+            case 500:
+            case 503:
+                msg = error.error.message;
+                break;
+            case 504:
+                msg = 'No se puede conectar al servidor. Comprueba tu conexion a la red - ' + error.statusText;
+                break;
+            default:
+                msg = error?.error?.message ?? 'Error de Sistema';
+                console.log(error);
+                break;
+        }
+    }
+    if (!msg) {
+        msg = error.statusText ?? 'Error inesperado o datos inexistentes.';
+    }
+
+    let tituloFinal = 'Error!';
+    let mensajeFinal;
+
+    if (msg.includes('Hmac::doVerify')) {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg == 'Server Error') {
+        console.log(error, msg);
+        return;
+    }
+    else if (msg.includes('[IMSSP]')) {
+        mensajeFinal = 'Error en consulta de registros.';
+    }
+    else if (msg.includes('Tiempo de espera de la')) {
+        mensajeFinal = 'Hubo un error en la solicitud de datos, por favor actualice (SHIFT + F5)';
+    }
+    else {
+        mensajeFinal = msg;
+    }
+    if (toast) {
+        mensajeToast('error', tituloFinal, mensajeFinal);
+    }
+    else {
+        mensajeAlerta('error', tituloFinal, mensajeFinal);
+    }
+
+    throw new Error(mensajeFinal);
+}

package/src/functions/index.ts

@@ -0,0 +1 @@
+export * from './public-api'

package/src/functions/local-storage.ts

@@ -0,0 +1,102 @@
+import moment from 'moment';
+import {jwtDecode} from 'jwt-decode';
+
+export interface JwtTokenResponse {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+    user: any;
+}
+
+export interface DataSessionStorage {
+    tokenStringKey?: string;
+    changePasswordKey?: string;
+    logoUrl?: string;
+    logoLogin?: string;
+    backgroundLogin?: string;
+    favicon?: string;
+    darkMode?: string;
+    serverTimestamp?: string;
+    apiDataKey?: string;
+}
+
+let dataSessionStorageKey: DataSessionStorage = {
+    tokenStringKey: 'JVSoftTkn',
+    changePasswordKey: 'chPwd',
+    logoUrl: 'logo_url',
+    logoLogin: 'login-logo',
+    backgroundLogin: 'login-background',
+    favicon: 'favicon',
+    darkMode: 'darkMode',
+    serverTimestamp: 'srvtmstp',
+    apiDataKey: 'reqDt',
+};
+export let localStorageKeys = dataSessionStorageKey;
+
+export function inicializarVariablesSessionStorage(datSesion: DataSessionStorage) {
+    dataSessionStorageKey = datSesion;
+}
+
+export function setJwtTokenData(data: string) {
+    localStorage.setItem(<string>dataSessionStorageKey.tokenStringKey, data)
+}
+export function jwtTokenData(key: string = <string>dataSessionStorageKey.tokenStringKey): JwtTokenResponse | null {
+    const tokenObj = localStorage.getItem(key);
+    try {
+        return JSON.parse(<string>tokenObj) as JwtTokenResponse;
+    } catch (error) {
+        return null;
+    }
+}
+
+export function jwtToken(key: string = <string>dataSessionStorageKey.tokenStringKey) {
+    const varJwtTokenData = jwtTokenData(key);
+    if (varJwtTokenData) {
+        return varJwtTokenData.access_token;
+    }
+    return '';
+}
+
+export function jwtTokenExpiracion(key: string = <string>dataSessionStorageKey.tokenStringKey) {
+    const jwtStr = jwtToken(key);
+    if (!jwtStr) return null;
+    try {
+        const decodedToken: any = jwtDecode(jwtStr);
+        return decodedToken.exp ? decodedToken.exp * 1000:null; // Convertir a milisegundos
+    } catch (e) {
+        return null;
+    }
+}
+
+export function jwtTokenExpiracionFaltante() {
+    return Math.abs(moment().diff(jwtTokenExpiracion(), 'seconds'));
+}
+
+export function setCambiarPwd(accion: boolean = true) {
+    localStorage.setItem(<string>dataSessionStorageKey.changePasswordKey, (accion ? 1:0).toString())
+}
+
+export function getCambiarPwd() {
+    const frmCambioPwd = localStorage.getItem(<string>dataSessionStorageKey.changePasswordKey);
+    if (!frmCambioPwd) {
+        return null;
+    }
+    return frmCambioPwd == '1';
+}
+
+export function delLocalStorage(keyElim: string[] = [
+    <string>dataSessionStorageKey.tokenStringKey,
+    <string>dataSessionStorageKey.changePasswordKey,
+    <string>dataSessionStorageKey.apiDataKey,
+]) {
+    keyElim.forEach(key => {
+        localStorage.removeItem(key);
+    });
+}
+
+export function getLocalStorage(key: string | undefined) {
+    return localStorage.getItem(<string>key);
+}
+export function setLocalStorage(key: string, value = '') {
+    localStorage.setItem(key, value.toString())
+}

package/src/functions/mat-form-controls/autocomplete.ts

@@ -0,0 +1,205 @@
+import {esNumero} from '../objects-arrays';
+import {AbstractControl} from '@angular/forms';
+import {untilDestroyed} from '@ngneat/until-destroy';
+import {debounceTime, finalize, isObservable, of, startWith, switchMap, tap} from 'rxjs';
+import {map} from 'rxjs/operators';
+
+/**
+ * Devuelve un valor de visualización para un elemento buscado.
+ * Compatible con listas simples, objetos y campos múltiples.
+ */
+export function mostrarValorEnBusqueda(campos: any, idxSel: any) {
+    const buscarEnLista = (lista: any[]) => {
+        if (!lista) return null;
+        if (campos.campoId === '*object*' || campos.campoId === '*objeto*') {
+            return lista.find((x: any) => JSON.stringify(x).trim() === JSON.stringify(idxSel).trim());
+        }
+        return lista.find((x: any) => x[campos.campoId] === idxSel);
+    };
+
+    const impDataMostrar = () => {
+        let vD = buscarEnLista(campos.lista) || (campos.opcExtra && buscarEnLista(campos.opcExtra));
+        if (!vD) return '';
+
+        if (Array.isArray(campos.campoValue)) {
+            return campos.campoValue.map((vCampo: any) => vD[vCampo] ?? '').join(' - ').trim();
+        }
+        return (vD[campos.campoValue] ?? '').trim();
+    };
+
+    if (esNumero(idxSel)) {
+        if ((idxSel > 0 && campos.lista?.length) || (idxSel && typeof idxSel === 'object')) {
+            return impDataMostrar();
+        }
+    } else if (campos.lista?.length) {
+        return impDataMostrar();
+    }
+    return '';
+}
+
+/**
+ * Filtra datos locales de un array basado en un valor de búsqueda.
+ */
+function filtrarDatosLocal(data: any[], value: any, campoBuscar: string | string[]) {
+    if (!value) return data;
+
+    const normalizar = (val: any) => val?.toString()?.toLowerCase() ?? '';
+    const esNum = !isNaN(Number(value));
+
+    return data.filter(item => {
+        const campos = Array.isArray(campoBuscar) ? campoBuscar : [campoBuscar];
+        return campos.some(campo => {
+            const campoVal = item[campo];
+            if (campoVal == null) return false;
+            return esNum
+                ? campoVal.toString().includes(value.toString())
+                : normalizar(campoVal).includes(normalizar(value));
+        });
+    });
+}
+
+/**
+ * Vincula un FormControl a datos locales para autocompletado.
+ */
+export function changeSelectData(objThis: any, { formControl, data, campoBuscar, variableResultado }: {
+    formControl: AbstractControl;
+    data: any[];
+    campoBuscar: string | string[];
+    variableResultado: string;
+}) {
+    objThis.filtrados[variableResultado] = formControl.valueChanges.pipe(untilDestroyed(objThis)).pipe(
+        startWith(''),
+        map(value => data ? filtrarDatosLocal(data, value, campoBuscar) : [])
+    );
+}
+
+/**
+ * Vincula un FormControl a datos locales obtenidos de dataServidor o dataServidorSuscripcion.
+ */
+export function changeSelect(control: any, formControl: AbstractControl, tipo: string, campoBuscar: string | string[], campoFiltro: string | null = null) {
+    const filtro = campoFiltro ?? tipo;
+    control.filtrados[filtro] = formControl.valueChanges.pipe(untilDestroyed(control)).pipe(
+        startWith(''),
+        map(value => {
+            const partes = tipo.split('.');
+            const varN =
+                control.dataServidor?.[partes[0]]?.[partes[1]] ??
+                control.dataServidor?.[tipo] ??
+                control.dataServidorSuscripcion?.[tipo]?.getValue();
+
+            return varN ? filtrarDatosLocal(varN, value, campoBuscar) : [];
+        })
+    );
+}
+
+/**
+ * Configuración para changeSelectReformateado.
+ */
+interface ChangeSelectConfig {
+    objThis: any;
+    tipoReq: string;
+    formControl: AbstractControl;
+    queryService: any;
+    campoId?: string;
+    minLength?: number;
+    dataExtra?: any;
+    dataExtraVariable?: { campo: string; ctrlValue: AbstractControl }[];
+    anonimo?: boolean;
+    variableResultado?: string;
+}
+
+/**
+ * Función genérica para vincular un FormControl con datos desde API o Promise.
+ * Preparada para migrar a signals en el futuro.
+ */
+export function changeSelectReformateado(config: ChangeSelectConfig) {
+    const {
+        objThis,
+        tipoReq,
+        formControl,
+        queryService,
+        campoId,
+        minLength = 3,
+        dataExtra = {},
+        dataExtraVariable = [],
+        anonimo = false,
+        variableResultado = tipoReq,
+    } = config;
+
+    formControl.valueChanges.pipe(
+        debounceTime(500),
+        tap(() => {
+            objThis.filtrados[variableResultado + 'tmp'] = isObservable(objThis.filtrados[variableResultado])
+                ? []
+                : objThis.filtrados[variableResultado] || [];
+            if (objThis.filtrados[variableResultado] !== objThis.filtrados[variableResultado + 'tmp']) {
+                objThis.filtrados[variableResultado] = [];
+            }
+            objThis.isLoading = true;
+        }),
+        switchMap(value => {
+            if (campoId) {
+                const existe = objThis.filtrados[variableResultado + 'tmp']
+                    .findIndex((item: any) => item[campoId] === value);
+                if (existe >= 0) {
+                    return of({ [tipoReq]: objThis.filtrados[variableResultado + 'tmp'] });
+                }
+            }
+            if (!value || value.length < minLength) {
+                objThis.isLoading = false;
+                return of({ [tipoReq]: [] });
+            }
+            const extraVars = Object.fromEntries(dataExtraVariable.map(v => [v.campo, v.ctrlValue.value]));
+            const query = queryService.getDataMethod('GET', tipoReq, { ...dataExtra, ...extraVars, txtBuscar: value }, anonimo);
+
+            if (esPromise(query)) {
+                return query.then((data: any) => ({ [tipoReq]: data[tipoReq] ?? [] }))
+                    .finally(() => { objThis.isLoading = false; });
+            }
+            return query.pipe(finalize(() => { objThis.isLoading = false; }));
+        })
+    ).subscribe((data: any) => {
+        objThis.filtrados[variableResultado] = data[tipoReq] ?? [];
+    });
+}
+
+/**
+ * Alias para compatibilidad.
+ */
+export function changeSelectDataApi(objThis: any, dataFiltro: any) {
+    return changeSelectReformateado({
+        objThis,
+        tipoReq: dataFiltro.tipoReq,
+        formControl: dataFiltro.formControl,
+        queryService: dataFiltro.queryService,
+        campoId: dataFiltro.campoId,
+        minLength: dataFiltro.minLength,
+        dataExtra: dataFiltro.dataExtra,
+        dataExtraVariable: dataFiltro.dataExtraVariable,
+        anonimo: dataFiltro.anonimo,
+        variableResultado: dataFiltro.variableResultado,
+    });
+}
+
+/**
+ * Alias para compatibilidad.
+ */
+export function changeSelectApi(control: any, queryService: any, formControl: AbstractControl, tipo: any, dataExtra = {}, dataExtraVariable: any[] | null = null, minLength = 1, anonimo = false) {
+    return changeSelectReformateado({
+        objThis: control,
+        tipoReq: tipo,
+        formControl,
+        queryService,
+        minLength,
+        dataExtra,
+        dataExtraVariable: dataExtraVariable ?? [],
+        anonimo,
+    });
+}
+
+/**
+ * Comprueba si un valor es una Promesa.
+ */
+function esPromise(valor: any): valor is Promise<any> {
+    return !!valor && typeof valor.then === 'function';
+}

package/src/functions/mat-form-controls/index.ts

@@ -0,0 +1,6 @@
+export * from './autocomplete'
+
+
+export function seleccionarTextoInput(event: any): void {
+    (event.target as HTMLInputElement).select();
+}

package/src/functions/ng-package.json

@@ -0,0 +1,5 @@
+{
+  "lib": {
+    "entryFile": "public-api.ts"
+  }
+}