@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/esm2022/lib/services/entity.service.mjs

@@ -0,0 +1,208 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class EntityService {
+    http;
+    translationService;
+    queriesUrl = '';
+    constructor(http, translationService) {
+        this.http = http;
+        this.translationService = translationService;
+        // Initialize queriesUrl in ngOnInit or a separate method
+        // since abstract properties can't be accessed in constructor
+    }
+    /**
+     * Initialize the service - call this after setting actionsUrl
+     */
+    initializeService() {
+        this.queriesUrl = this.actionsUrl.replace('actions', 'queries');
+    }
+    /**
+     * Convert ListParams to HttpParams for GET requests
+     */
+    getListQueryParams(listParams) {
+        const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;
+        let params = new HttpParams();
+        params = params.append('size', String(size));
+        params = params.append('offset', String(page));
+        if (sort && sort.length) {
+            const orderBy = sort
+                .map((s) => {
+                let order = '';
+                if (s.order === 1)
+                    order = ' asc';
+                else if (s.order === -1)
+                    order = ' desc';
+                return `${s.field}${order}`;
+            })
+                .join(', ');
+            params = params.append('orderby', orderBy);
+        }
+        if (filterQuery) {
+            params = params.append('filter', filterQuery);
+        }
+        if (displayFields && displayFields.length) {
+            params = params.append('displayfields', displayFields.join(','));
+        }
+        return params;
+    }
+    /**
+     * Convert ListParams to body parameters for POST requests
+     */
+    getBodyParams(listParams) {
+        const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;
+        const bodyParams = {};
+        bodyParams.size = size;
+        bodyParams.offset = page;
+        if (sort && sort.length) {
+            bodyParams.orderBy = sort
+                .map((s) => {
+                let order = '';
+                if (s.order === 1)
+                    order = ' asc';
+                else if (s.order === -1)
+                    order = ' desc';
+                return `${s.field}${order}`;
+            })
+                .join(', ');
+        }
+        if (filterQuery) {
+            bodyParams.filter = filterQuery;
+        }
+        if (displayFields && displayFields.length) {
+            bodyParams.displayfields = displayFields.join(',');
+        }
+        return bodyParams;
+    }
+    /**
+     * Default error handler
+     */
+    handleError = (error) => {
+        let errorMessage = 'An error occurred';
+        if (this.translationService) {
+            errorMessage = this.translationService.translate('error.generic');
+        }
+        if (error.status) {
+            switch (error.status) {
+                case 401:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.unauthorized')
+                        : 'Unauthorized';
+                    break;
+                case 403:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.forbidden')
+                        : 'Forbidden';
+                    break;
+                case 404:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.not_found')
+                        : 'Not found';
+                    break;
+                case 500:
+                    errorMessage = this.translationService
+                        ? this.translationService.translate('error.server_error')
+                        : 'Server error';
+                    break;
+                default:
+                    if (error.error && error.error.message) {
+                        errorMessage = error.error.message;
+                    }
+                    else if (error.statusText) {
+                        errorMessage = error.statusText;
+                    }
+            }
+        }
+        else if (error.message) {
+            errorMessage = error.message;
+        }
+        console.error('EntityService Error:', error);
+        return throwError(() => new Error(errorMessage));
+    };
+    /**
+     * List entities with pagination, sorting, and filtering
+     */
+    list(listParams = {}) {
+        const params = this.getListQueryParams(listParams);
+        return this.http.get(this.entityUrl, { params })
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Get entity by ID
+     */
+    get(id) {
+        return this.http.get(`${this.entityUrl}/${id}`)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Create new entity
+     */
+    insert(entity) {
+        return this.http.post(this.entityUrl, entity)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Update existing entity
+     */
+    update(id, entity) {
+        return this.http.put(`${this.entityUrl}/${id}`, entity)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Delete entity by ID
+     */
+    delete(id) {
+        return this.http.delete(`${this.entityUrl}/${id}`, { observe: 'response' })
+            .pipe(map(() => undefined), catchError(this.handleError));
+    }
+    /**
+     * Execute custom filter action
+     */
+    listCustomFilter(listParams, action) {
+        const bodyParams = this.getBodyParams(listParams);
+        return this.http.post(`${this.actionsUrl}/${action}`, bodyParams)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Execute custom query
+     */
+    executeQuery(queryName, params = {}) {
+        return this.http.post(`${this.queriesUrl}/${queryName}`, params)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Execute custom action
+     */
+    executeAction(actionName, params = {}) {
+        return this.http.post(`${this.actionsUrl}/${actionName}`, params)
+            .pipe(catchError(this.handleError));
+    }
+    /**
+     * Check if entity exists by ID
+     */
+    exists(id) {
+        return this.http.head(`${this.entityUrl}/${id}`)
+            .pipe(map(() => true), catchError((error) => {
+            if (error.status === 404) {
+                return [false];
+            }
+            return this.handleError(error);
+        }));
+    }
+    /**
+     * Bulk delete entities
+     */
+    bulkDelete(ids) {
+        return this.http.post(`${this.actionsUrl}/bulkDelete`, { ids }, { observe: 'response' })
+            .pipe(map(() => undefined), catchError(this.handleError));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EntityService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/entity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\n\nexport interface SortMeta {\n  field: string;\n  order: number; // 1 for asc, -1 for desc\n}\n\nexport interface ListParams {\n  page?: number;\n  size?: number;\n  sort?: SortMeta[];\n  filterQuery?: string;\n  displayFields?: string[];\n}\n\nexport interface BodyParams {\n  offset?: number;\n  size?: number;\n  orderBy?: string;\n  filter?: string;\n  displayfields?: string;\n}\n\nexport interface EntityListResponse<T> {\n  contents: T[];\n  totalElements: number;\n  totalPages: number;\n  size?: number;\n  number?: number;\n  first?: boolean;\n  last?: boolean;\n}\n\n// Interface para o serviço de tradução (duck typing)\nexport interface TranslationService {\n  translate(key: string, params?: any): string;\n}\n\n@Injectable()\nexport abstract class EntityService<T> {\n  protected abstract entityUrl: string;\n  protected abstract actionsUrl: string;\n  protected queriesUrl: string = '';\n\n  constructor(\n    protected http: HttpClient,\n    protected translationService?: TranslationService\n  ) {\n    // Initialize queriesUrl in ngOnInit or a separate method\n    // since abstract properties can't be accessed in constructor\n  }\n\n  /**\n   * Initialize the service - call this after setting actionsUrl\n   */\n  protected initializeService(): void {\n    this.queriesUrl = this.actionsUrl.replace('actions', 'queries');\n  }\n\n  /**\n   * Convert ListParams to HttpParams for GET requests\n   */\n  protected getListQueryParams(listParams: ListParams): HttpParams {\n    const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;\n    let params = new HttpParams();\n    \n    params = params.append('size', String(size));\n    params = params.append('offset', String(page));\n    \n    if (sort && sort.length) {\n      const orderBy = sort\n        .map((s) => {\n          let order = '';\n          if (s.order === 1) order = ' asc';\n          else if (s.order === -1) order = ' desc';\n          return `${s.field}${order}`;\n        })\n        .join(', ');\n      params = params.append('orderby', orderBy);\n    }\n\n    if (filterQuery) {\n      params = params.append('filter', filterQuery);\n    }\n\n    if (displayFields && displayFields.length) {\n      params = params.append('displayfields', displayFields.join(','));\n    }\n\n    return params;\n  }\n\n  /**\n   * Convert ListParams to body parameters for POST requests\n   */\n  protected getBodyParams(listParams: ListParams): BodyParams {\n    const { page = 0, size = 10, sort = [], filterQuery = '', displayFields = [] } = listParams;\n    const bodyParams: BodyParams = {};\n\n    bodyParams.size = size;\n    bodyParams.offset = page;\n\n    if (sort && sort.length) {\n      bodyParams.orderBy = sort\n        .map((s) => {\n          let order = '';\n          if (s.order === 1) order = ' asc';\n          else if (s.order === -1) order = ' desc';\n          return `${s.field}${order}`;\n        })\n        .join(', ');\n    }\n\n    if (filterQuery) {\n      bodyParams.filter = filterQuery;\n    }\n\n    if (displayFields && displayFields.length) {\n      bodyParams.displayfields = displayFields.join(',');\n    }\n\n    return bodyParams;\n  }\n\n  /**\n   * Default error handler\n   */\n  protected handleError = (error: any): Observable<never> => {\n    let errorMessage = 'An error occurred';\n    \n    if (this.translationService) {\n      errorMessage = this.translationService.translate('error.generic');\n    }\n    \n    if (error.status) {\n      switch (error.status) {\n        case 401:\n          errorMessage = this.translationService \n            ? this.translationService.translate('error.unauthorized')\n            : 'Unauthorized';\n          break;\n        case 403:\n          errorMessage = this.translationService\n            ? this.translationService.translate('error.forbidden')\n            : 'Forbidden';\n          break;\n        case 404:\n          errorMessage = this.translationService\n            ? this.translationService.translate('error.not_found')\n            : 'Not found';\n          break;\n        case 500:\n          errorMessage = this.translationService\n            ? this.translationService.translate('error.server_error')\n            : 'Server error';\n          break;\n        default:\n          if (error.error && error.error.message) {\n            errorMessage = error.error.message;\n          } else if (error.statusText) {\n            errorMessage = error.statusText;\n          }\n      }\n    } else if (error.message) {\n      errorMessage = error.message;\n    }\n\n    console.error('EntityService Error:', error);\n    return throwError(() => new Error(errorMessage));\n  };\n\n  /**\n   * List entities with pagination, sorting, and filtering\n   */\n  list(listParams: ListParams = {}): Observable<EntityListResponse<T>> {\n    const params = this.getListQueryParams(listParams);\n    return this.http.get<EntityListResponse<T>>(this.entityUrl, { params })\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Get entity by ID\n   */\n  get(id: any): Observable<T> {\n    return this.http.get<T>(`${this.entityUrl}/${id}`)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Create new entity\n   */\n  insert(entity: T): Observable<T> {\n    return this.http.post<T>(this.entityUrl, entity)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Update existing entity\n   */\n  update(id: any, entity: T): Observable<T> {\n    return this.http.put<T>(`${this.entityUrl}/${id}`, entity)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Delete entity by ID\n   */\n  delete(id: any): Observable<void> {\n    return this.http.delete<void>(`${this.entityUrl}/${id}`, { observe: 'response' })\n      .pipe(\n        map(() => undefined),\n        catchError(this.handleError)\n      );\n  }\n\n  /**\n   * Execute custom filter action\n   */\n  listCustomFilter(listParams: ListParams, action: string): Observable<EntityListResponse<T>> {\n    const bodyParams = this.getBodyParams(listParams);\n    return this.http.post<EntityListResponse<T>>(`${this.actionsUrl}/${action}`, bodyParams)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Execute custom query\n   */\n  executeQuery(queryName: string, params: any = {}): Observable<any> {\n    return this.http.post<any>(`${this.queriesUrl}/${queryName}`, params)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Execute custom action\n   */\n  executeAction(actionName: string, params: any = {}): Observable<any> {\n    return this.http.post<any>(`${this.actionsUrl}/${actionName}`, params)\n      .pipe(catchError(this.handleError));\n  }\n\n  /**\n   * Check if entity exists by ID\n   */\n  exists(id: any): Observable<boolean> {\n    return this.http.head(`${this.entityUrl}/${id}`)\n      .pipe(\n        map(() => true),\n        catchError((error) => {\n          if (error.status === 404) {\n            return [false];\n          }\n          return this.handleError(error);\n        })\n      );\n  }\n\n  /**\n   * Bulk delete entities\n   */\n  bulkDelete(ids: any[]): Observable<void> {\n    return this.http.post<void>(`${this.actionsUrl}/bulkDelete`, { ids }, { observe: 'response' })\n      .pipe(\n        map(() => undefined),\n        catchError(this.handleError)\n      );\n  }\n}\n"]}

package/esm2022/lib/services/mask.service.mjs

@@ -0,0 +1,121 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MaskService {
+    /**
+     * Aplica máscara de CPF (999.999.999-99) - 100% numérico
+     */
+    applyCpfMask(value) {
+        if (!value)
+            return '';
+        // Remove todos os caracteres não numéricos
+        const numbers = value.replace(/\D/g, '');
+        // Limita a 11 dígitos
+        const limitedNumbers = numbers.substring(0, 11);
+        // Aplica a máscara progressivamente
+        if (limitedNumbers.length <= 3) {
+            return limitedNumbers;
+        }
+        else if (limitedNumbers.length <= 6) {
+            return limitedNumbers.replace(/(\d{3})(\d+)/, '$1.$2');
+        }
+        else if (limitedNumbers.length <= 9) {
+            return limitedNumbers.replace(/(\d{3})(\d{3})(\d+)/, '$1.$2.$3');
+        }
+        else {
+            return limitedNumbers.replace(/(\d{3})(\d{3})(\d{3})(\d+)/, '$1.$2.$3-$4');
+        }
+    }
+    /**
+     * Aplica máscara de CNPJ alfanumérico (XX.XXX.XXX/XXXX-XX)
+     * Aceita letras e números em todos os caracteres
+     */
+    applyCnpjMask(value) {
+        if (!value)
+            return '';
+        // Remove caracteres especiais, mantém letras e números
+        const cleaned = value.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+        // Limita a 14 caracteres
+        const limitedChars = cleaned.substring(0, 14);
+        // Aplica a máscara progressivamente
+        if (limitedChars.length <= 2) {
+            return limitedChars;
+        }
+        else if (limitedChars.length <= 5) {
+            return limitedChars.replace(/(\w{2})(\w+)/, '$1.$2');
+        }
+        else if (limitedChars.length <= 8) {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w+)/, '$1.$2.$3');
+        }
+        else if (limitedChars.length <= 12) {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w{3})(\w+)/, '$1.$2.$3/$4');
+        }
+        else {
+            return limitedChars.replace(/(\w{2})(\w{3})(\w{3})(\w{4})(\w+)/, '$1.$2.$3/$4-$5');
+        }
+    }
+    /**
+     * Aplica a máscara apropriada baseada no tipo de pessoa
+     * CPF: 100% numérico (999.999.999-99)
+     * CNPJ: alfanumérico (XX.XXX.XXX/XXXX-XX)
+     */
+    applyDocumentMask(value, typePerson) {
+        if (!value)
+            return '';
+        if (typePerson === 'NATURAL_PERSON') {
+            return this.applyCpfMask(value);
+        }
+        else {
+            return this.applyCnpjMask(value);
+        }
+    }
+    /**
+     * Remove a máscara de um documento (mantém apenas alfanuméricos)
+     */
+    removeMask(value) {
+        if (!value)
+            return '';
+        return value.replace(/[^a-zA-Z0-9]/g, '');
+    }
+    /**
+     * Determina se um documento é CPF ou CNPJ baseado no comprimento
+     */
+    getDocumentType(value) {
+        if (!value)
+            return 'unknown';
+        const cleaned = this.removeMask(value);
+        if (cleaned.length <= 11) {
+            return 'cpf';
+        }
+        else if (cleaned.length <= 14) {
+            return 'cnpj';
+        }
+        return 'unknown';
+    }
+    /**
+     * Valida se um CPF tem formato válido (11 dígitos numéricos)
+     */
+    isValidCpfFormat(value) {
+        if (!value)
+            return false;
+        const cleaned = value.replace(/\D/g, '');
+        return cleaned.length === 11 && /^\d{11}$/.test(cleaned);
+    }
+    /**
+     * Valida se um CNPJ tem formato válido (14 caracteres alfanuméricos)
+     */
+    isValidCnpjFormat(value) {
+        if (!value)
+            return false;
+        const cleaned = this.removeMask(value);
+        return cleaned.length === 14;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: MaskService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mask.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/mask.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MaskService {\n\n  /**\n   * Aplica máscara de CPF (999.999.999-99) - 100% numérico\n   */\n  applyCpfMask(value: string): string {\n    if (!value) return '';\n    \n    // Remove todos os caracteres não numéricos\n    const numbers = value.replace(/\\D/g, '');\n    \n    // Limita a 11 dígitos\n    const limitedNumbers = numbers.substring(0, 11);\n    \n    // Aplica a máscara progressivamente\n    if (limitedNumbers.length <= 3) {\n      return limitedNumbers;\n    } else if (limitedNumbers.length <= 6) {\n      return limitedNumbers.replace(/(\\d{3})(\\d+)/, '$1.$2');\n    } else if (limitedNumbers.length <= 9) {\n      return limitedNumbers.replace(/(\\d{3})(\\d{3})(\\d+)/, '$1.$2.$3');\n    } else {\n      return limitedNumbers.replace(/(\\d{3})(\\d{3})(\\d{3})(\\d+)/, '$1.$2.$3-$4');\n    }\n  }\n\n  /**\n   * Aplica máscara de CNPJ alfanumérico (XX.XXX.XXX/XXXX-XX)\n   * Aceita letras e números em todos os caracteres\n   */\n  applyCnpjMask(value: string): string {\n    if (!value) return '';\n    \n    // Remove caracteres especiais, mantém letras e números\n    const cleaned = value.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();\n    \n    // Limita a 14 caracteres\n    const limitedChars = cleaned.substring(0, 14);\n    \n    // Aplica a máscara progressivamente\n    if (limitedChars.length <= 2) {\n      return limitedChars;\n    } else if (limitedChars.length <= 5) {\n      return limitedChars.replace(/(\\w{2})(\\w+)/, '$1.$2');\n    } else if (limitedChars.length <= 8) {\n      return limitedChars.replace(/(\\w{2})(\\w{3})(\\w+)/, '$1.$2.$3');\n    } else if (limitedChars.length <= 12) {\n      return limitedChars.replace(/(\\w{2})(\\w{3})(\\w{3})(\\w+)/, '$1.$2.$3/$4');\n    } else {\n      return limitedChars.replace(/(\\w{2})(\\w{3})(\\w{3})(\\w{4})(\\w+)/, '$1.$2.$3/$4-$5');\n    }\n  }\n\n  /**\n   * Aplica a máscara apropriada baseada no tipo de pessoa\n   * CPF: 100% numérico (999.999.999-99)\n   * CNPJ: alfanumérico (XX.XXX.XXX/XXXX-XX)\n   */\n  applyDocumentMask(value: string, typePerson: 'NATURAL_PERSON' | 'JURIDICAL_PERSON'): string {\n    if (!value) return '';\n    \n    if (typePerson === 'NATURAL_PERSON') {\n      return this.applyCpfMask(value);\n    } else {\n      return this.applyCnpjMask(value);\n    }\n  }\n\n  /**\n   * Remove a máscara de um documento (mantém apenas alfanuméricos)\n   */\n  removeMask(value: string): string {\n    if (!value) return '';\n    return value.replace(/[^a-zA-Z0-9]/g, '');\n  }\n\n  /**\n   * Determina se um documento é CPF ou CNPJ baseado no comprimento\n   */\n  getDocumentType(value: string): 'cpf' | 'cnpj' | 'unknown' {\n    if (!value) return 'unknown';\n    \n    const cleaned = this.removeMask(value);\n    \n    if (cleaned.length <= 11) {\n      return 'cpf';\n    } else if (cleaned.length <= 14) {\n      return 'cnpj';\n    }\n    \n    return 'unknown';\n  }\n\n  /**\n   * Valida se um CPF tem formato válido (11 dígitos numéricos)\n   */\n  isValidCpfFormat(value: string): boolean {\n    if (!value) return false;\n    const cleaned = value.replace(/\\D/g, '');\n    return cleaned.length === 11 && /^\\d{11}$/.test(cleaned);\n  }\n\n  /**\n   * Valida se um CNPJ tem formato válido (14 caracteres alfanuméricos)\n   */\n  isValidCnpjFormat(value: string): boolean {\n    if (!value) return false;\n    const cleaned = this.removeMask(value);\n    return cleaned.length === 14;\n  }\n}\n"]}

package/esm2022/lib/services/permission.service.mjs

@@ -0,0 +1,180 @@
+import { Injectable, Optional, Inject } from '@angular/core';
+import { of } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PermissionService {
+    http;
+    authService;
+    PERMISSION_ENDPOINT = 'platform/authorization/queries/checkAccess';
+    permissionCache = new Map();
+    cacheExpiry = new Map();
+    CACHE_DURATION = 5 * 60 * 1000; // 5 minutes in milliseconds
+    constructor(http, authService) {
+        this.http = http;
+        this.authService = authService;
+    }
+    /**
+     * Check access for a single permission
+     */
+    checkAccess(resource, action, context) {
+        const cacheKey = this.getCacheKey(resource, action, context);
+        // Check cache first
+        const cachedResult = this.getCachedPermission(cacheKey);
+        if (cachedResult !== null) {
+            return of(cachedResult.allowed);
+        }
+        // Make API request
+        const request = {
+            permissions: [{ resource, action, context }]
+        };
+        return this.http.post(this.PERMISSION_ENDPOINT, request).pipe(map(response => {
+            if (response.results && response.results.length > 0) {
+                const result = response.results[0];
+                this.cachePermission(cacheKey, result);
+                return result.allowed;
+            }
+            return false;
+        }), catchError(error => {
+            console.error('Permission check failed:', error);
+            // On error, deny access by default
+            return of(false);
+        }));
+    }
+    /**
+     * Check access for multiple permissions
+     */
+    checkMultipleAccess(permissions) {
+        const uncachedPermissions = [];
+        const results = [];
+        // Check cache for each permission
+        permissions.forEach(permission => {
+            const cacheKey = this.getCacheKey(permission.resource, permission.action, permission.context);
+            const cachedResult = this.getCachedPermission(cacheKey);
+            if (cachedResult !== null) {
+                results.push(cachedResult);
+            }
+            else {
+                uncachedPermissions.push(permission);
+            }
+        });
+        // If all permissions are cached, return immediately
+        if (uncachedPermissions.length === 0) {
+            return of(results);
+        }
+        // Make API request for uncached permissions
+        const request = {
+            permissions: uncachedPermissions
+        };
+        return this.http.post(this.PERMISSION_ENDPOINT, request).pipe(map(response => {
+            if (response.results) {
+                // Cache the new results
+                response.results.forEach(result => {
+                    const cacheKey = this.getCacheKey(result.resource, result.action);
+                    this.cachePermission(cacheKey, result);
+                });
+                // Combine cached and new results
+                return [...results, ...response.results];
+            }
+            return results;
+        }), catchError(error => {
+            console.error('Multiple permission check failed:', error);
+            // On error, return cached results and deny uncached ones
+            const deniedResults = uncachedPermissions.map(permission => ({
+                allowed: false,
+                resource: permission.resource,
+                action: permission.action,
+                reason: 'Permission check failed'
+            }));
+            return of([...results, ...deniedResults]);
+        }));
+    }
+    /**
+     * Check if user can read a resource
+     */
+    canRead(resource, context) {
+        return this.checkAccess(resource, 'read', context);
+    }
+    /**
+     * Check if user can write to a resource
+     */
+    canWrite(resource, context) {
+        return this.checkAccess(resource, 'write', context);
+    }
+    /**
+     * Check if user can delete a resource
+     */
+    canDelete(resource, context) {
+        return this.checkAccess(resource, 'delete', context);
+    }
+    /**
+     * Check if user can execute an action on a resource
+     */
+    canExecute(resource, action, context) {
+        return this.checkAccess(resource, action, context);
+    }
+    /**
+     * Clear permission cache
+     */
+    clearCache() {
+        this.permissionCache.clear();
+        this.cacheExpiry.clear();
+    }
+    /**
+     * Clear expired cache entries
+     */
+    clearExpiredCache() {
+        const now = Date.now();
+        const expiredKeys = [];
+        this.cacheExpiry.forEach((expiry, key) => {
+            if (expiry < now) {
+                expiredKeys.push(key);
+            }
+        });
+        expiredKeys.forEach(key => {
+            this.permissionCache.delete(key);
+            this.cacheExpiry.delete(key);
+        });
+    }
+    /**
+     * Generate cache key for permission
+     */
+    getCacheKey(resource, action, context) {
+        const contextStr = context ? JSON.stringify(context) : '';
+        return `${resource}:${action}:${contextStr}`;
+    }
+    /**
+     * Get cached permission result
+     */
+    getCachedPermission(cacheKey) {
+        const expiry = this.cacheExpiry.get(cacheKey);
+        if (expiry && expiry > Date.now()) {
+            return this.permissionCache.get(cacheKey) || null;
+        }
+        // Remove expired entry
+        this.permissionCache.delete(cacheKey);
+        this.cacheExpiry.delete(cacheKey);
+        return null;
+    }
+    /**
+     * Cache permission result
+     */
+    cachePermission(cacheKey, result) {
+        this.permissionCache.set(cacheKey, result);
+        this.cacheExpiry.set(cacheKey, Date.now() + this.CACHE_DURATION);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, deps: [{ token: i1.HttpClient }, { token: 'AuthService', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['AuthService']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permission.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/permission.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional, Inject } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\n\nexport interface PermissionRequest {\n  resource: string;\n  action: string;\n  context?: { [key: string]: any };\n}\n\nexport interface PermissionResponse {\n  allowed: boolean;\n  resource: string;\n  action: string;\n  reason?: string;\n}\n\nexport interface CheckAccessRequest {\n  permissions: PermissionRequest[];\n}\n\nexport interface CheckAccessResponse {\n  results: PermissionResponse[];\n}\n\n// Interface para AuthService (duck typing)\nexport interface AuthServiceInterface {\n  isAuthenticated(): boolean;\n  getAccessToken(): string | null;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PermissionService {\n  private readonly PERMISSION_ENDPOINT = 'platform/authorization/queries/checkAccess';\n  private permissionCache = new Map<string, PermissionResponse>();\n  private cacheExpiry = new Map<string, number>();\n  private readonly CACHE_DURATION = 5 * 60 * 1000; // 5 minutes in milliseconds\n\n  constructor(\n    private http: HttpClient,\n    @Optional() @Inject('AuthService') private authService?: AuthServiceInterface\n  ) {}\n\n  /**\n   * Check access for a single permission\n   */\n  checkAccess(resource: string, action: string, context?: { [key: string]: any }): Observable<boolean> {\n    const cacheKey = this.getCacheKey(resource, action, context);\n    \n    // Check cache first\n    const cachedResult = this.getCachedPermission(cacheKey);\n    if (cachedResult !== null) {\n      return of(cachedResult.allowed);\n    }\n\n    // Make API request\n    const request: CheckAccessRequest = {\n      permissions: [{ resource, action, context }]\n    };\n\n    return this.http.post<CheckAccessResponse>(this.PERMISSION_ENDPOINT, request).pipe(\n      map(response => {\n        if (response.results && response.results.length > 0) {\n          const result = response.results[0];\n          this.cachePermission(cacheKey, result);\n          return result.allowed;\n        }\n        return false;\n      }),\n      catchError(error => {\n        console.error('Permission check failed:', error);\n        // On error, deny access by default\n        return of(false);\n      })\n    );\n  }\n\n  /**\n   * Check access for multiple permissions\n   */\n  checkMultipleAccess(permissions: PermissionRequest[]): Observable<PermissionResponse[]> {\n    const uncachedPermissions: PermissionRequest[] = [];\n    const results: PermissionResponse[] = [];\n\n    // Check cache for each permission\n    permissions.forEach(permission => {\n      const cacheKey = this.getCacheKey(permission.resource, permission.action, permission.context);\n      const cachedResult = this.getCachedPermission(cacheKey);\n      \n      if (cachedResult !== null) {\n        results.push(cachedResult);\n      } else {\n        uncachedPermissions.push(permission);\n      }\n    });\n\n    // If all permissions are cached, return immediately\n    if (uncachedPermissions.length === 0) {\n      return of(results);\n    }\n\n    // Make API request for uncached permissions\n    const request: CheckAccessRequest = {\n      permissions: uncachedPermissions\n    };\n\n    return this.http.post<CheckAccessResponse>(this.PERMISSION_ENDPOINT, request).pipe(\n      map(response => {\n        if (response.results) {\n          // Cache the new results\n          response.results.forEach(result => {\n            const cacheKey = this.getCacheKey(result.resource, result.action);\n            this.cachePermission(cacheKey, result);\n          });\n          \n          // Combine cached and new results\n          return [...results, ...response.results];\n        }\n        return results;\n      }),\n      catchError(error => {\n        console.error('Multiple permission check failed:', error);\n        // On error, return cached results and deny uncached ones\n        const deniedResults = uncachedPermissions.map(permission => ({\n          allowed: false,\n          resource: permission.resource,\n          action: permission.action,\n          reason: 'Permission check failed'\n        }));\n        return of([...results, ...deniedResults]);\n      })\n    );\n  }\n\n  /**\n   * Check if user can read a resource\n   */\n  canRead(resource: string, context?: { [key: string]: any }): Observable<boolean> {\n    return this.checkAccess(resource, 'read', context);\n  }\n\n  /**\n   * Check if user can write to a resource\n   */\n  canWrite(resource: string, context?: { [key: string]: any }): Observable<boolean> {\n    return this.checkAccess(resource, 'write', context);\n  }\n\n  /**\n   * Check if user can delete a resource\n   */\n  canDelete(resource: string, context?: { [key: string]: any }): Observable<boolean> {\n    return this.checkAccess(resource, 'delete', context);\n  }\n\n  /**\n   * Check if user can execute an action on a resource\n   */\n  canExecute(resource: string, action: string, context?: { [key: string]: any }): Observable<boolean> {\n    return this.checkAccess(resource, action, context);\n  }\n\n  /**\n   * Clear permission cache\n   */\n  clearCache(): void {\n    this.permissionCache.clear();\n    this.cacheExpiry.clear();\n  }\n\n  /**\n   * Clear expired cache entries\n   */\n  clearExpiredCache(): void {\n    const now = Date.now();\n    const expiredKeys: string[] = [];\n\n    this.cacheExpiry.forEach((expiry, key) => {\n      if (expiry < now) {\n        expiredKeys.push(key);\n      }\n    });\n\n    expiredKeys.forEach(key => {\n      this.permissionCache.delete(key);\n      this.cacheExpiry.delete(key);\n    });\n  }\n\n  /**\n   * Generate cache key for permission\n   */\n  private getCacheKey(resource: string, action: string, context?: { [key: string]: any }): string {\n    const contextStr = context ? JSON.stringify(context) : '';\n    return `${resource}:${action}:${contextStr}`;\n  }\n\n  /**\n   * Get cached permission result\n   */\n  private getCachedPermission(cacheKey: string): PermissionResponse | null {\n    const expiry = this.cacheExpiry.get(cacheKey);\n    if (expiry && expiry > Date.now()) {\n      return this.permissionCache.get(cacheKey) || null;\n    }\n    \n    // Remove expired entry\n    this.permissionCache.delete(cacheKey);\n    this.cacheExpiry.delete(cacheKey);\n    return null;\n  }\n\n  /**\n   * Cache permission result\n   */\n  private cachePermission(cacheKey: string, result: PermissionResponse): void {\n    this.permissionCache.set(cacheKey, result);\n    this.cacheExpiry.set(cacheKey, Date.now() + this.CACHE_DURATION);\n  }\n}\n"]}