@jvsoft/utils 0.0.10 → 0.0.11

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,275 @@
+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';
+
+export function mostrarValorEnBusqueda(campos: any, idxSel: any) {
+    const impDataMostrar = () => {
+        let vD;
+        if (campos.campoId == '*object*' || campos.campoId == '*objeto*') {
+            console.log(campos);
+            vD = campos.lista.find((x: any) => JSON.stringify(x).trim() == JSON.stringify(idxSel).trim());
+            console.log(vD);
+        }
+        else {
+            vD = campos.lista.find((x: any) => x[campos.campoId] == idxSel);
+        }
+        if (!vD && campos.opcExtra) {
+            console.log('eval ', campos.opcExtra);
+            if (campos.campoId == '*object*' || campos.campoId == '*objeto*') {
+                console.log(campos);
+                vD = campos.opcExtra.find((x: any) => JSON.stringify(x).trim() == JSON.stringify(idxSel).trim());
+                console.log(vD);
+            }
+            else {
+                vD = campos.opcExtra.find((x: any) => x[campos.campoId] == idxSel);
+            }
+        }
+        if (vD) {
+            let txtFinal = '';
+            if (Array.isArray(campos.campoValue)) {
+                campos.campoValue.forEach((vCampo: any, idx: any) => {
+                    txtFinal += (vD[vCampo] ?? '');
+                    if (idx < campos.campoValue.length - 1) {
+                        txtFinal += ' - ';
+                    }
+                });
+            }
+            else {
+                txtFinal = vD[campos.campoValue] ?? '';
+            }
+            return txtFinal.trim();
+        }
+        else {
+            console.log('ASSSSS ----- SSSS ');
+        }
+        return '';
+    };
+    if (esNumero(idxSel)) {
+        if (idxSel > 0 && campos.lista?.length > 0) {
+            return impDataMostrar();
+        }
+        else if (idxSel && typeof idxSel == 'object') {
+            return impDataMostrar();
+        }
+    }
+    else {
+        if (campos.lista?.length > 0) {
+            return impDataMostrar();
+        }
+    }
+    return '';
+}
+
+
+export function changeSelectData(objThis: any, dataFiltro: {
+    formControl: AbstractControl,
+    data: any[],
+    campoBuscar: string | string[],
+    variableResultado: string,
+}) {
+    objThis['filtrados'][dataFiltro.variableResultado] = dataFiltro.formControl.valueChanges.pipe(untilDestroyed(objThis)).pipe(
+        startWith(''),
+        map(value => {
+
+            const varN = dataFiltro.data;
+            if (varN) {
+                if (value) {
+                    return varN.map(x => x).filter(dat => {
+                        if (Array.isArray(dataFiltro.campoBuscar)) {
+                            let encontrado = false;
+
+                            for (const vCampo of dataFiltro.campoBuscar) {
+                                // console.log(vCampo, value, dat[vCampo]);
+                                if (isNaN(Number(value))) {
+                                    // NO ES NUMERO
+                                    if (value && dat[vCampo] && dat[vCampo].toLowerCase().includes(value?.toString().toLowerCase())) {
+                                        encontrado = true;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (value && dat[vCampo] && dat[vCampo].toString().includes(value?.toString())) {
+                                        encontrado = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            return encontrado;
+                        }
+                        else {
+                            if (isNaN(Number(value))) {
+                                return dat[dataFiltro.campoBuscar].toLowerCase().includes(value?.toString().toLowerCase());
+                            }
+                            else {
+                                return dat[dataFiltro.campoBuscar].toString().includes(value?.toString());
+                            }
+                        }
+                    });
+                }
+                return varN;
+            }
+            return false;
+        })
+    );
+}
+
+export function changeSelect(control: any, formControl: AbstractControl, tipo: any, campoBuscar: any, campoFiltro = null) {
+    // console.log(formControl);
+    // const formGroup = formControl.parent.controls;
+    // console.warn( Object.keys(formGroup).find(name => formControl === formGroup[name]) || null );
+    if (!campoFiltro) {
+        campoFiltro = tipo;
+    }
+    control['filtrados'][campoFiltro ?? '__'] = formControl.valueChanges.pipe(untilDestroyed(control)).pipe(
+        startWith(''),
+        map(value => {
+            // console.warn(value);
+
+            const partes = tipo.split('.');
+            let varN;
+            if (control['dataServidor']) {
+                varN = (partes.length > 1) ? control['dataServidor'][partes[0]][partes[1]]:control['dataServidor'][tipo];
+            }
+            else if (control['dataServidorSuscripcion']) {
+                varN = control['dataServidorSuscripcion'][tipo].getValue();
+            }
+            if (varN) {
+                if (value) {
+                    return varN.map((x: any) => x).filter((dat: any) => {
+                        if (Array.isArray(campoBuscar)) {
+                            let encontrado = false;
+
+                            for (const vCampo of campoBuscar) {
+                                // console.log(vCampo, value, dat[vCampo]);
+                                if (isNaN(Number(value))) {
+                                    // NO ES NUMERO
+                                    if (value && dat[vCampo] && dat[vCampo].toLowerCase().includes(value?.toString().toLowerCase())) {
+                                        encontrado = true;
+                                        break;
+                                    }
+                                }
+                                else {
+                                    if (value && dat[vCampo] && dat[vCampo].toString().includes(value?.toString())) {
+                                        encontrado = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            return encontrado;
+                        }
+                        else {
+                            if (isNaN(Number(value))) {
+                                return dat[campoBuscar].toLowerCase().includes(value?.toString().toLowerCase());
+                            }
+                            else {
+                                return dat[campoBuscar].toString().includes(value?.toString());
+                            }
+                        }
+                    });
+                }
+                return varN;
+            }
+            return false;
+        })
+    );
+}
+
+export function changeSelectDataApi(objThis: any, dataFiltro: {
+    tipoReq: string,
+    campoId?: string,
+    minLength?: number,
+    dataExtra?: any,
+    dataExtraVariable?: any,
+    anonimo?: boolean,
+    queryService: any,
+
+    formControl: AbstractControl,
+    variableResultado?: string,
+}) {
+    if (!dataFiltro.variableResultado) {
+        dataFiltro.variableResultado = dataFiltro.tipoReq;
+    }
+    const idFiltrado: string = dataFiltro.variableResultado;
+    dataFiltro.formControl.valueChanges.pipe(
+        debounceTime(500),
+        tap(() => {
+            objThis.filtrados[dataFiltro.variableResultado + 'tmp'] = isObservable(objThis.filtrados[idFiltrado]) ? []:objThis.filtrados[idFiltrado] || [];
+            if (objThis.filtrados[idFiltrado] !== objThis.filtrados[idFiltrado + 'tmp']) {
+                objThis.filtrados[idFiltrado] = [];
+            }
+            objThis.isLoading = true;
+        }),
+        switchMap(value => {
+            if (dataFiltro.campoId) {
+                const busquedaActual2 = objThis.filtrados[idFiltrado + 'tmp'].findIndex((item: any) => item[dataFiltro.campoId ?? '--'] === value);
+                if (busquedaActual2 >= 0) {
+                    return of({[dataFiltro.tipoReq]: objThis.filtrados[idFiltrado + 'tmp']});
+                }
+            }
+            return !value || value.length < (dataFiltro.minLength ?? 3) ? []:(
+                dataFiltro.queryService.getDataMethod('GET', dataFiltro.tipoReq, {
+                    ...(dataFiltro.dataExtra ?? {}),
+                    ...(dataFiltro.dataExtraVariable ? Object.fromEntries(dataFiltro.dataExtraVariable.map((objData: any) => [objData.campo, objData.ctrlValue.value])):{}),
+                    txtBuscar: value,
+                }, dataFiltro.anonimo).pipe(
+                    finalize(() => objThis.isLoading = false),
+                )
+            );
+        })
+    ).subscribe((data: any) => {
+        objThis.filtrados[idFiltrado] = data[dataFiltro.tipoReq] ?? [];
+    });
+}
+
+export function changeSelectApi(control: any, queryService: any, formControl: AbstractControl, tipo: any, dataExtra = {}, dataExtraVariable: any[] | null = null, minLength = 1, anonimo = false) {
+    formControl.valueChanges.pipe(
+        debounceTime(500),
+        tap((value) => {
+            control['filtrados'][tipo + 'tmp'] = isObservable(control['filtrados'][tipo]) ? []:control['filtrados'][tipo];
+            if (control['filtrados'][tipo] != control['filtrados'][tipo + 'tmp']) {
+                control['filtrados'][tipo] = [];
+            }
+            control['isLoading'] = true;
+        }),
+
+        switchMap(value => {
+            const formGroup = <any>formControl.parent?.controls;
+            const nombreControl = Object.keys(formGroup).find(name => formControl === formGroup[name]) || null;
+            if (nombreControl && control['filtrados'][tipo + 'tmp'] && control['filtrados'][tipo + 'tmp'].length > 0) {
+                const busquedaActual = control['filtrados'][tipo + 'tmp'].findIndex((item: any) => item[nombreControl] == value);
+                if (busquedaActual >= 0) {
+                    const vRet: any = {};
+                    vRet[tipo] = control['filtrados'][tipo + 'tmp'];
+                    control['isLoading'] = false;
+                    return of(vRet);
+                }
+            }
+            if (!value || value.length < minLength) {
+                return [];
+            }
+
+            const dataExtraVariableData: any = {};
+            if (dataExtraVariable) {
+                // @ts-ignore
+                for (const objData of dataExtraVariable) {
+                    dataExtraVariableData[objData.campo] = objData.ctrlValue.value;
+                }
+            }
+            return queryService.getDataMethod('GET', tipo, {...dataExtra, ...dataExtraVariableData, ...{txtBuscar: value}}, anonimo).pipe(
+                finalize(() => {
+                    control['isLoading'] = false;
+                }),
+            );
+
+        })
+    ).subscribe((data: any) => {
+        if (data[tipo] == undefined) {
+            control['filtrados'][tipo] = [];
+        }
+        else {
+            control['filtrados'][tipo] = data[tipo];
+        }
+    });
+}

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"
+  }
+}

package/src/functions/number.ts

@@ -0,0 +1,3 @@
+export function roundToDecimal(number: number, decimal: number): number {
+    return parseFloat(number.toFixed(decimal));
+}

package/src/functions/object-transformation.ts

@@ -0,0 +1,37 @@
+import {formatDate} from '@angular/common';
+import {formatearFecha} from './date';
+
+export function objectPropertiesToType(formFields: Record<string, any>) {
+    Object.keys(formFields).filter(control => !!formFields[control]).forEach(control => {
+        if (/^dt[a-zA-Z]+/.test(control)) {
+            formFields[control] = formatDate(formFields[control], 'yyyy-MM-dd HH:mm', 'es-PE');
+        }
+        else if (control.startsWith('d')) {
+            formFields[control] = formatearFecha(formFields[control]);
+        }
+        else if (control.startsWith('n')) {
+            formFields[control] = Number(formFields[control]);
+        }
+    });
+
+    return formFields;
+}
+
+export function objectPropertiesBoolean(formFields: Record<string, any>, retorno: 'boolean' | 'bit' = 'boolean') {
+    Object.keys(formFields).forEach(control => {
+        const valRetorno = (ctrl: any) => {
+            switch (retorno) {
+                case 'boolean':
+                    formFields[ctrl] = formFields[ctrl] == 1;
+                    break;
+                case 'bit':
+                    formFields[ctrl] = formFields[ctrl] ? 1:0;
+                    break;
+            }
+        };
+        if (control.charAt(0) == 'b' || (control.charAt(0) == 'i' && control.indexOf('Estado') !== -1)) {
+            valRetorno(control);
+        }
+    });
+    return formFields;
+}