lib-common-angular 0.0.9 → 0.0.11

package/projects/lib-common-angular/src/lib/componentes/shared/services/dynamic-menu.service.ts

@@ -0,0 +1,439 @@
+import { Injectable } from '@angular/core';
+// import { HttpClient } from '@angular/common/http';
+// import { Observable, of, throwError } from 'rxjs';
+// import { catchError, map, tap } from 'rxjs/operators';
+import { MenuConfig, MenuItem, MenuService } from '../interfaces/menu.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DynamicMenuService implements MenuService {
+  // private readonly API_BASE_URL = '/api/menus';
+  private menuCache = new Map<string, MenuConfig>();
+
+  constructor(
+    // private http: HttpClient
+  ) {}
+
+  // Obtener configuración del menú
+  async getMenuConfig(menuId: string): Promise<MenuConfig> {
+    // Verificar cache primero
+    if (this.menuCache.has(menuId)) {
+      return this.menuCache.get(menuId)!;
+    }
+
+    // Comentado: Petición HTTP real
+    // try {
+    //   const config = await this.http.get<MenuConfig>(`${this.API_BASE_URL}/${menuId}`).toPromise();
+    //   if (config) {
+    //     this.menuCache.set(menuId, config);
+    //     return config;
+    //   }
+    //   throw new Error('Configuración de menú no encontrada');
+    // } catch (error) {
+    //   // Si falla la API, usar configuración por defecto
+    //   return this.getDefaultMenuConfig(menuId);
+    // }
+
+    // Data estática para desarrollo
+    const config = this.getDefaultMenuConfig(menuId);
+    this.menuCache.set(menuId, config);
+    return config;
+  }
+
+  // Actualizar configuración del menú
+  async updateMenuConfig(menuId: string, config: MenuConfig): Promise<void> {
+    // Comentado: Petición HTTP real
+    // try {
+    //   await this.http.put(`${this.API_BASE_URL}/${menuId}`, config).toPromise();
+    //   this.menuCache.set(menuId, config);
+    // } catch (error) {
+    //   throw new Error('Error al actualizar configuración del menú');
+    // }
+
+    // Data estática para desarrollo
+    this.menuCache.set(menuId, config);
+    console.log(`Configuración actualizada para menú: ${menuId}`, config);
+  }
+
+  // Obtener elementos del menú
+  async getMenuItems(menuId: string): Promise<MenuItem[]> {
+    const config = await this.getMenuConfig(menuId);
+    return config.items;
+  }
+
+  // Agregar elemento al menú
+  async addMenuItem(menuId: string, item: MenuItem): Promise<void> {
+    // Comentado: Petición HTTP real
+    // try {
+    //   const config = await this.getMenuConfig(menuId);
+    //   config.items.push(item);
+    //   await this.updateMenuConfig(menuId, config);
+    // } catch (error) {
+    //   throw new Error('Error al agregar elemento del menú');
+    // }
+
+    // Data estática para desarrollo
+    try {
+      const config = await this.getMenuConfig(menuId);
+      config.items.push(item);
+      await this.updateMenuConfig(menuId, config);
+      console.log(`Elemento agregado al menú: ${menuId}`, item);
+    } catch (error) {
+      console.error(error);
+      throw new Error('Error al agregar elemento del menú');
+    }
+  }
+
+  // Eliminar elemento del menú
+  async removeMenuItem(menuId: string, itemId: string): Promise<void> {
+    // Comentado: Petición HTTP real
+    // try {
+    //   const config = await this.getMenuConfig(menuId);
+    //   config.items = this.removeItemRecursive(config.items, itemId);
+    //   await this.updateMenuConfig(menuId, config);
+    // } catch (error) {
+    //   throw new Error('Error al eliminar elemento del menú');
+    // }
+
+    // Data estática para desarrollo
+    try {
+      const config = await this.getMenuConfig(menuId);
+      config.items = this.removeItemRecursive(config.items, itemId);
+      await this.updateMenuConfig(menuId, config);
+      console.log(`Elemento eliminado del menú: ${menuId}, itemId: ${itemId}`);
+    } catch (error) {
+      console.error(error);
+      throw new Error('Error al eliminar elemento del menú');
+    }
+  }
+
+  // Actualizar elemento del menú
+  async updateMenuItem(menuId: string, itemId: string, updates: Partial<MenuItem>): Promise<void> {
+    // Comentado: Petición HTTP real
+    // try {
+    //   const config = await this.getMenuConfig(menuId);
+    //   this.updateItemRecursive(config.items, itemId, updates);
+    //   await this.updateMenuConfig(menuId, config);
+    // } catch (error) {
+    //   throw new Error('Error al actualizar elemento del menú');
+    // }
+
+    // Data estática para desarrollo
+    try {
+      const config = await this.getMenuConfig(menuId);
+      this.updateItemRecursive(config.items, itemId, updates);
+      await this.updateMenuConfig(menuId, config);
+      console.log(`Elemento actualizado en menú: ${menuId}, itemId: ${itemId}`, updates);
+    } catch (error) {
+      console.error(error);
+      throw new Error('Error al actualizar elemento del menú');
+    }
+  }
+
+  // Limpiar cache
+  clearCache(menuId?: string): void {
+    if (menuId) {
+      this.menuCache.delete(menuId);
+    } else {
+      this.menuCache.clear();
+    }
+    console.log('Cache limpiado', menuId ? `para menú: ${menuId}` : 'completamente');
+  }
+
+  // Obtener configuración por defecto
+  // eslint-disable-next-line max-lines-per-function
+  private getDefaultMenuConfig(menuId: string): MenuConfig {
+    const defaultConfigs: Record<string, MenuConfig> = {
+      'main-menu': {
+        id: 'main-menu',
+        name: 'Menú Principal',
+        items: [
+          {
+            id: 'home',
+            label: 'Inicio',
+            icon: 'pi pi-home',
+            routerLink: ['/'],
+            type: 'item',
+            order: 1
+          },
+          {
+            id: 'dashboard',
+            label: 'Dashboard',
+            icon: 'pi pi-chart-bar',
+            routerLink: ['/dashboard'],
+            type: 'item',
+            order: 2
+          },
+          {
+            id: 'separator-1',
+            label: '',
+            separator: true,
+            type: 'separator',
+            order: 3
+          },
+          {
+            id: 'administration',
+            label: 'Administración',
+            icon: 'pi pi-cog',
+            type: 'group',
+            order: 4,
+            items: [
+              {
+                id: 'users',
+                label: 'Usuarios',
+                icon: 'pi pi-users',
+                routerLink: ['/admin/users'],
+                type: 'item',
+                order: 1,
+                permissions: ['admin.users.read']
+              },
+              {
+                id: 'roles',
+                label: 'Roles',
+                icon: 'pi pi-shield',
+                routerLink: ['/admin/roles'],
+                type: 'item',
+                order: 2,
+                permissions: ['admin.roles.read']
+              }
+            ]
+          },
+          {
+            id: 'reports',
+            label: 'Reportes',
+            icon: 'pi pi-file',
+            type: 'group',
+            order: 5,
+            items: [
+              {
+                id: 'sales-report',
+                label: 'Reporte de Ventas',
+                icon: 'pi pi-chart-line',
+                routerLink: ['/reports/sales'],
+                type: 'item',
+                order: 1,
+                permissions: ['reports.sales.read']
+              },
+              {
+                id: 'inventory-report',
+                label: 'Reporte de Inventario',
+                icon: 'pi pi-box',
+                routerLink: ['/reports/inventory'],
+                type: 'item',
+                order: 2,
+                permissions: ['reports.inventory.read']
+              }
+            ]
+          }
+        ],
+        theme: 'light',
+        orientation: 'vertical',
+        collapsible: true,
+        showIcons: true,
+        showBadges: true,
+        maxDepth: 3
+      },
+      'sidebar-menu': {
+        id: 'sidebar-menu',
+        name: 'Menú Lateral',
+        items: [
+          {
+            id: 'dashboard',
+            label: 'Dashboard',
+            icon: 'pi pi-home',
+            routerLink: ['/dashboard'],
+            type: 'item',
+            order: 1
+          },
+          {
+            id: 'profile',
+            label: 'Perfil',
+            icon: 'pi pi-user',
+            routerLink: ['/profile'],
+            type: 'item',
+            order: 2
+          },
+          {
+            id: 'settings',
+            label: 'Configuración',
+            icon: 'pi pi-cog',
+            routerLink: ['/settings'],
+            type: 'item',
+            order: 3
+          }
+        ],
+        theme: 'dark',
+        orientation: 'vertical',
+        collapsible: false,
+        showIcons: true,
+        showBadges: false,
+        maxDepth: 2
+      },
+      'dashboard3-menu': {
+        id: 'dashboard3-menu',
+        name: 'Dashboard 3 Menu',
+        items: [
+          {
+            id: 'home',
+            label: 'Home',
+            icon: 'pi pi-fw pi-home',
+            type: 'group',
+            order: 1,
+            items: [
+              {
+                id: 'dashboard',
+                label: 'Dashboard',
+                icon: 'pi pi-fw pi-home',
+                routerLink: ['/'],
+                type: 'item',
+                order: 1
+              },
+              {
+                id: 'crud',
+                label: 'Crud',
+                icon: 'pi pi-fw pi-pencil',
+                routerLink: ['/pages/crud'],
+                type: 'item',
+                order: 2
+              }
+            ]
+          },
+          {
+            id: 'pages',
+            label: 'Pages',
+            icon: 'pi pi-fw pi-briefcase',
+            type: 'group',
+            order: 2,
+            items: [
+              {
+                id: 'menu-demo',
+                label: 'Menu Demo',
+                icon: 'pi pi-fw pi-bars',
+                routerLink: ['/menu-demo'],
+                type: 'item',
+                order: 1
+              },
+              {
+                id: 'dashboard-demo',
+                label: 'Dashboard Demo',
+                icon: 'pi pi-fw pi-chart-line',
+                routerLink: ['/dashboard-demo'],
+                type: 'item',
+                order: 2
+              }
+            ]
+          }
+        ],
+        theme: 'light',
+        orientation: 'vertical',
+        collapsible: true,
+        showIcons: true,
+        showBadges: true,
+        maxDepth: 3
+      }
+    };
+
+    return defaultConfigs[menuId] || {
+      id: menuId,
+      name: 'Menú',
+      items: [],
+      theme: 'light',
+      orientation: 'vertical',
+      collapsible: false,
+      showIcons: true,
+      showBadges: true,
+      maxDepth: 3
+    };
+  }
+
+  // Eliminar elemento recursivamente
+  private removeItemRecursive(items: MenuItem[], itemId: string): MenuItem[] {
+    return items.filter(item => {
+      if (item.id === itemId) {
+        return false;
+      }
+      if (item.items) {
+        item.items = this.removeItemRecursive(item.items, itemId);
+      }
+      return true;
+    });
+  }
+
+  // Actualizar elemento recursivamente
+  private updateItemRecursive(items: MenuItem[], itemId: string, updates: Partial<MenuItem>): boolean {
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].id === itemId) {
+        items[i] = { ...items[i], ...updates };
+        return true;
+      }
+      if (items[i].items && this.updateItemRecursive(items[i].items!, itemId, updates)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Métodos adicionales para gestión avanzada
+  async duplicateMenu(sourceMenuId: string, newMenuId: string, newName: string): Promise<MenuConfig> {
+    const sourceConfig = await this.getMenuConfig(sourceMenuId);
+    const newConfig: MenuConfig = {
+      ...sourceConfig,
+      id: newMenuId,
+      name: newName
+    };
+    
+    await this.updateMenuConfig(newMenuId, newConfig);
+    console.log(`Menú duplicado: ${sourceMenuId} -> ${newMenuId}`);
+    return newConfig;
+  }
+
+  async exportMenuConfig(menuId: string): Promise<string> {
+    const config = await this.getMenuConfig(menuId);
+    const jsonConfig = JSON.stringify(config, null, 2);
+    console.log(`Configuración exportada para menú: ${menuId}`);
+    return jsonConfig;
+  }
+
+  async importMenuConfig(menuId: string, configJson: string): Promise<void> {
+    // Comentado: Validación HTTP real
+    // try {
+    //   const config = JSON.parse(configJson) as MenuConfig;
+    //   config.id = menuId;
+    //   await this.updateMenuConfig(menuId, config);
+    // } catch (error) {
+    //   throw new Error('Error al importar configuración del menú');
+    // }
+
+    // Data estática para desarrollo
+    try {
+      const config = JSON.parse(configJson) as MenuConfig;
+      config.id = menuId;
+      await this.updateMenuConfig(menuId, config);
+      console.log(`Configuración importada para menú: ${menuId}`);
+    } catch (error) {
+      console.error(error);
+      throw new Error('Error al importar configuración del menú');
+    }
+  }
+
+  // Métodos para gestión de permisos
+  async getMenuItemsByPermissions(menuId: string, permissions: string[]): Promise<MenuItem[]> {
+    const config = await this.getMenuConfig(menuId);
+    return this.filterItemsByPermissions(config.items, permissions);
+  }
+
+  private filterItemsByPermissions(items: MenuItem[], permissions: string[]): MenuItem[] {
+    return items
+      .filter(item => {
+        if (!item.permissions || item.permissions.length === 0) {
+          return true;
+        }
+        return item.permissions.some(permission => permissions.includes(permission));
+      })
+      .map(item => ({
+        ...item,
+        items: item.items ? this.filterItemsByPermissions(item.items, permissions) : undefined
+      }));
+  }
+} 

package/projects/lib-common-angular/src/lib/componentes/shared/services/excel-export.service.ts

@@ -0,0 +1,83 @@
+import { Injectable } from '@angular/core';
+import { MessageService } from 'primeng/api';
+
+import { ExcelExportConfig } from '@juliaosistem/core-dtos'; // Assuming you have a model for the config
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ExcelExportService {
+
+  constructor(private messageService: MessageService) {}
+
+  async exportToExcel(config: ExcelExportConfig): Promise<void> {
+    if (!config.data?.length) {
+      this.messageService.add({
+        severity: 'warn',
+        summary: 'No Data',
+        detail: 'No data available to export',
+        life: 3000,
+      });
+      return;
+    }
+
+    await this.performExcelExport(config);
+  }
+
+  private async performExcelExport(config: ExcelExportConfig): Promise<void> {
+    try {
+      const XLSX = await import('xlsx');
+      const exportData = this.prepareDataForExport(config);
+      const ws = XLSX.utils.json_to_sheet(exportData);
+      const wb = XLSX.utils.book_new();
+      XLSX.utils.book_append_sheet(wb, ws, 'Data');
+      
+      const fileName = this.generateFileName(config.fileName);
+      XLSX.writeFile(wb, fileName);
+      
+      this.messageService.add({
+        severity: 'success',
+        summary: 'Export Successful',
+        detail: `Data exported to ${fileName}`,
+        life: 3000,
+      });
+    } catch {
+      this.messageService.add({
+        severity: 'error',
+        summary: 'Export Failed',
+        detail: 'Could not load Excel export library',
+        life: 3000,
+      });
+    }
+  }
+
+  private prepareDataForExport(config: ExcelExportConfig): Record<string, unknown>[] {
+    return config.data.map(item => {
+      const exportItem: Record<string, unknown> = {};
+      const fields = config.fieldOrder.length ? config.fieldOrder : 
+                    Object.keys(item).filter(key => !config.excludeFields.includes(key));
+      
+      fields.forEach(field => {
+        const label = config.fieldLabels[field] || field;
+        const value = item[field];
+        exportItem[label] = this.formatValue(value);
+      });
+      
+      return exportItem;
+    });
+  }
+
+  private formatValue(value: unknown): string | number | boolean | null {
+    if (value === null || value === undefined) return null;
+    if (typeof value === 'boolean' || typeof value === 'number') return value;
+    if (Array.isArray(value)) return value.join(', ');
+    if (typeof value === 'object') return JSON.stringify(value);
+    if (value instanceof Date) return value.toLocaleDateString();
+    return String(value);
+  }
+
+  private generateFileName(customFileName?: string): string {
+    const dateSuffix = new Date().toISOString().split('T')[0];
+    return `${customFileName || 'export'}_${dateSuffix}.xlsx`;
+  }
+}

package/projects/lib-common-angular/src/lib/componentes/shared/services/generic-crud.service/generic-crud.service.ts

@@ -0,0 +1,79 @@
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { Injectable, Inject, Optional } from "@angular/core";
+import { Observable } from "rxjs";
+import { PlantillaResponse } from "juliaositembackenexpress/dist/utils/PlantillaResponse";
+import { LibConfigService } from "../../../../config/lib-config.service";
+import { MetaDataService } from "../meta-data.service.ts/meta-data.service";
+import { QueryParams } from "juliaositembackenexpress/dist/utils/queryParams";
+
+@Injectable({ providedIn: "root" })
+export class GenericCrudHttpService<T> {
+  protected basePathUrl: string;
+
+  constructor(
+    protected http: HttpClient,
+    private config: LibConfigService,
+    private meta: MetaDataService,
+    @Inject('ENDPOINT_KEY') @Optional() private endpointKey?: string
+  ) {
+    this.basePathUrl = this.endpointKey
+      ? this.config.get<string>(this.endpointKey) || "http://localhost:3000"
+      : "http://localhost:3000";
+  }
+
+  // Construye headers a partir de un objeto
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private buildHeaders(headersObj: Record<string, any>): HttpHeaders {
+    let headers = new HttpHeaders();
+    Object.keys(headersObj).forEach(key => {
+      if (headersObj[key] !== undefined && headersObj[key] !== null) {
+        headers = headers.set(key, headersObj[key]);
+      }
+    });
+    return headers;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  all(queryParams?: Record<string, any>): Observable<PlantillaResponse<T>> {
+    const metaParams = this.meta.get('listar');
+    const headers = this.buildHeaders({ ...metaParams, ...queryParams });
+    return this.http.get<PlantillaResponse<T>>(`${this.basePathUrl}/all`, headers ? { headers } : {});
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  add(payload: T, topic: string, queryParams?: Record<string, any>): Observable<PlantillaResponse<T>> {
+    const metaParams = this.meta.get('guardar');
+    const headers = this.buildHeaders({ ...metaParams, ...queryParams });
+    return this.http.post<PlantillaResponse<T>>(
+      `${this.basePathUrl}/add`,
+      payload,
+      { headers }
+    );
+  }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ update(payload: T & { id: any }, queryParams?: QueryParams): Observable<PlantillaResponse<T>> {
+  const topic = queryParams?.topic;
+  const headers = topic ? this.buildHeaders({ topic }) : undefined;
+
+  return this.http.put<PlantillaResponse<T>>(
+    `${this.basePathUrl}/${payload.id}`,
+    payload,
+    { headers }
+  );
+}
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  delete(id: string, queryParams?: Record<string, any>): Observable<PlantillaResponse<T>> {
+    const metaParams = this.meta.get('eliminar');
+    const headers = this.buildHeaders({ ...metaParams, ...queryParams });
+    return this.http.delete<PlantillaResponse<T>>(
+      `${this.basePathUrl}/${id}`,
+      { headers }
+    );
+  }
+
+  getMockData(): T[] {
+    return [];
+  }
+}