ngx-redi-core 0.0.2

package/README.md

@@ -0,0 +1,24 @@
+# NgxRediCore
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 15.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project ngx-redi-core` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ngx-redi-core`.
+> Note: Don't forget to add `--project ngx-redi-core` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build ngx-redi-core` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build ngx-redi-core`, go to the dist folder `cd dist/ngx-redi-core` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test ngx-redi-core` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/ngx-redi-core",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "ngx-redi-core",
+  "version": "0.0.2",
+  "peerDependencies": {
+    "@angular/common": "^15.2.0",
+    "@angular/core": "^15.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false
+}

package/src/lib/modules/interceptors/secure.interceptor.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { SecureInterceptor } from './secure.interceptor';
+
+describe('SecureInterceptor', () => {
+  beforeEach(() => TestBed.configureTestingModule({
+    providers: [
+      SecureInterceptor
+      ]
+  }));
+
+  it('should be created', () => {
+    const interceptor: SecureInterceptor = TestBed.inject(SecureInterceptor);
+    expect(interceptor).toBeTruthy();
+  });
+});

package/src/lib/modules/interceptors/secure.interceptor.ts

@@ -0,0 +1,211 @@
+import 'reflect-metadata';
+import { Injectable } from '@angular/core';
+import {
+  HttpRequest,
+  HttpHandler,
+  HttpEvent,
+  HttpInterceptor,
+  HttpContextToken,
+  HttpResponse
+} from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { CifradoService } from '../secure/services/cifrado.service';
+import { TOKEN_SECURE } from '../secure/model/secure-factory.model';
+
+/** Request token para el contexto Http */
+export const REQUEST_TOKEN = new HttpContextToken<any>(() => { });
+/** Response token para el contexto Http */
+export const RESPONSE_TOKEN = new HttpContextToken<any>(() => { });
+
+/**
+ * Interceptor de seguridad que cifra y descifra información sensible en las peticiones Web
+ * @decorator `@Injectable()`
+ */
+@Injectable()
+export class SecureInterceptor implements HttpInterceptor {
+  constructor(private cifradoService: CifradoService) { }
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    /** Ciframos los datos de la petición */
+    return next.handle(this.cifrarRequest(request))
+      .pipe(map(event => {
+        if (event instanceof HttpResponse) {
+          return event.clone({
+            body: this.descifrarResponse(request, event)
+          });
+        }
+        return event
+      }));
+  }
+
+  /**
+   * Regresa una respuesta HTTP descifrada
+   * @param request - Petición web
+   * @param response - Respuesta web a descifrar
+   * @returns Respuesta http descifrada
+   */
+  private descifrarResponse(request: HttpRequest<any>, response: HttpResponse<any>): any {
+    let responseDefinition = request.context.get(RESPONSE_TOKEN);
+    if (responseDefinition && response.body) {
+      return this.descifrarDatos(response.body, responseDefinition)
+    }
+    return response.body;
+  }
+
+  /**
+   * Cifra los datos de la petición interceptada y regresa una nueva petición con los datos cifrados
+   * @param request - Petición Http
+   * @returns - Petición con datos cifrados
+   */
+  private cifrarRequest(request: HttpRequest<any>): HttpRequest<any> {
+    let newRequest: HttpRequest<any> = request;
+    switch (request.method) {
+      case 'POST':
+        newRequest = request.clone({ body: this.cifrarDatos(request.body) });
+        break;
+      default:
+        newRequest = request.clone({ url: this.cifrarPeticionUrl(request) });
+        break;
+    }
+    return newRequest;
+  }
+
+  /**
+   * Realiza el cifrado de la petición cuando los datos a cifrar se mandan en la URL
+   * @param request - Petición HTTP
+   * @returns StringQueryParams cifrados en URL
+   */
+  private cifrarPeticionUrl(request: HttpRequest<any>): string {
+    let requestData = request.context.get(REQUEST_TOKEN);
+    let queryParams: string[] = [];
+    let queryObject = Object.fromEntries(new URL(request.url).searchParams.entries());
+    if (typeof requestData === 'object') {
+      Object.entries(queryObject).forEach(([key, value]) => {
+        if (!requestData[key]) {
+          requestData[key] = value;
+        }
+      });
+      Object.entries(this.cifrarDatos(requestData)).forEach(([key, value]) => {
+        if (value && typeof value !== 'object') {
+          queryParams.push(`${key}=${encodeURI((value || '') as string)}`);
+        }
+      });
+    }
+    return `${(request.url || '').split('?')[0]}${queryParams.length ? '?' + queryParams.join('&') : ''}`
+  }
+
+  /**
+   * Valida si la propiedad de un objeto es segura
+   * @param data - Objeto a validar
+   * @param key - Propiedad del objeto a validar
+   * @returns True si es una propiedad segura
+   */
+  private isValidDecorator(data: any, key: string): boolean {
+    return data != null && this.propertyHasDecorator(data, key);
+  }
+
+  /**
+   * Valida si la propiedad tiene el decorador de seguridad
+   * @param data - Entidad objetivo
+   * @param key - Nombre de la propiedad
+   */
+  private propertyHasDecorator(data: any, key: string): boolean {
+    return Reflect.hasMetadata(TOKEN_SECURE, data, key);
+  }
+
+  /**
+   * Valida si un objeto es seguro
+   * @param data - Objeto a validar
+   * @returns True si existe el decorador @Secure
+   */
+  private hasDecorator(data: any): boolean {
+    return data != null && Reflect.hasMetadata(TOKEN_SECURE, data);
+  }
+
+  /**
+   * Valida si es un objeto y no esta nulo
+   * @param object - Objeto a validar
+   * @returns True si es un objeto valido
+   */
+  private isValidObject(object: any): boolean {
+    return object != null && typeof object === 'object';
+  }
+
+  /**
+   * Cifra los datos especificados
+   * @param datos - Datos a cifrar
+   * @returns Regresa el objeto con los datos cifrados
+   */
+  private cifrarDatos(datos: any): any {
+    if (this.isValidObject(datos)) {
+      const contenedor: any = {};
+      Object.entries(datos).forEach(([key, value]) => {
+        if (this.isValidObject(value)) {
+          contenedor[key] = this.cifrarDatos(value)
+        }
+        else if (this.isValidDecorator(datos, key)) {
+          contenedor[key] = this.cifrarTexto(value as string);
+        }
+        else {
+          contenedor[key] = value;
+        }
+      });
+      return this.hasDecorator(datos) ? this.cifrarTexto(JSON.stringify(contenedor)) : contenedor;
+    }
+    return datos;
+  }
+
+  /**
+   * Descifra los datos a partir de una definición
+   * @param datos - Datos a descifrar
+   * @param definition - Definición de los datos con los decoradores seguros
+   * @returns Datos descifrados
+   */
+  private descifrarDatos(datos: any, definition: any): any {
+    let contenedor: any = datos;
+    if (datos && definition) {
+
+      if (Array.isArray(datos)) {
+        contenedor = [];
+        Object.entries(datos).forEach(([, value]) => {
+          contenedor.push(this.descifrarDatos(value, definition));
+        })
+      }
+      else {
+        contenedor = {};
+        Object.entries(datos).forEach(([key, value]) => {
+          if (this.isValidObject(value)) {
+            contenedor[key] = this.descifrarDatos(value, definition.prototype[key])
+          }
+          else if (this.propertyHasDecorator(definition.prototype, key)) {
+            contenedor[key] = this.decifrarTexto(value as string);
+          }
+          else {
+            contenedor[key] = value;
+          }
+        });
+      }
+    }
+    return contenedor;
+  }
+
+  /**
+   * Cifra el texto especificado
+   * @param datos - Contiene los datos que se cifraran
+   * @returns Datos cifrados
+   */
+  private cifrarTexto(datos: string): string {
+    return this.cifradoService.cifrar(datos);
+  }
+
+  /**
+   * Descifra el texto proporcionado
+   * @param datos - Contiene los datos que se descifraran
+   * @returns Datos descifrados
+   */
+  private decifrarTexto(datosCifrados: string): string {
+    return this.cifradoService.descifrar(datosCifrados);
+  }
+}
+

package/src/lib/modules/secure/model/secure-factory.model.spec.ts

@@ -0,0 +1,7 @@
+import { secure } from "./secure-factory.model";
+
+describe('SecureFactory', () => {
+  it('should create an instance', () => {
+    expect(secure).toBeTruthy();
+  });
+});

package/src/lib/modules/secure/model/secure-factory.model.ts

@@ -0,0 +1,28 @@
+import 'reflect-metadata'
+
+/**
+ * Fabrica de decoradores para del modulo de seguridad
+ * @param cipher Indica el algoritmo de cifrado
+ */
+export function secure(cipher?: string) {
+    /**
+     * Función para la fabrica de decoradores de clases y propiedades
+     * @param target Target del decorador
+     * @param propertyKey Nombre de la propiedad
+     * @returns Function de devolución para la fabrica de decoradores
+     */
+    return function (target: any, propertyKey?: string) {
+        if (propertyKey) {
+            Reflect.defineProperty(target, propertyKey, { writable: true });
+            Reflect.defineMetadata(TOKEN_SECURE, cipher, target, propertyKey);
+        }
+        else {
+            Reflect.defineMetadata(TOKEN_SECURE, cipher, target.prototype);
+        }
+    }
+}
+
+/**
+ * Token para decorador de seguridad
+ */
+export const TOKEN_SECURE = secure.name;

package/src/lib/modules/secure/model/tipo-operacion.enum.ts

@@ -0,0 +1,19 @@
+/**
+ * Enumera los tipos de operación para el modulo de seguridad
+ */
+export enum TipoOperacion {
+    /**
+     * Indica que la operación a realizar es una codificación
+     */
+    Codificar,
+
+    /**
+     * Indica que la operación a realizar es una decodificación
+     */
+    Decodificar,
+
+    /**
+     * Indica que se deberá realizar la codificación y decodificación
+     */
+    CodificarYDecodificar
+}

package/src/lib/modules/secure/secure.module.ts

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+
+
+@NgModule({
+  declarations: [],
+  imports: [
+    CommonModule
+  ],
+  exports:[
+    
+  ]
+})
+export class SecureModule { }

package/src/lib/modules/secure/services/cifrado.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { CifradoService } from './cifrado.service';
+
+describe('CifradoService', () => {
+  let service: CifradoService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(CifradoService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/modules/secure/services/cifrado.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Servicio de cifrado y descifrado de información
+ * @decorator `@Injectable()`
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class CifradoService {
+
+  constructor() {
+  }
+
+  /**
+   * Método que realiza el cifrado de los datos tipo Texto
+   * @param data - Texto a cifrar
+   * @returns Datos cifrados en modo tex
+   */
+  public cifrar(data: string): string {
+    return window.btoa(encodeURIComponent(data));
+  }
+
+  /**
+   * Método que descifra el texto
+   * @params data - Texto a descifrar
+   * @returns Texto descifrado
+   */
+  public descifrar(data: string): string {
+    return window.atob(decodeURIComponent(data));
+  }
+}

package/src/lib/ngx-redi-core.component.spec.ts

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { NgxRediCoreComponent } from './ngx-redi-core.component';
+
+describe('NgxRediCoreComponent', () => {
+  let component: NgxRediCoreComponent;
+  let fixture: ComponentFixture<NgxRediCoreComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [ NgxRediCoreComponent ]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(NgxRediCoreComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/src/lib/ngx-redi-core.component.ts

@@ -0,0 +1,15 @@
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'lib-ngx-redi-core',
+  template: `
+    <p>
+      ngx-redi-core works!
+    </p>
+  `,
+  styles: [
+  ]
+})
+export class NgxRediCoreComponent {
+
+}

package/src/lib/ngx-redi-core.module.ts

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { NgxRediCoreComponent } from './ngx-redi-core.component';
+
+
+
+@NgModule({
+  declarations: [
+    NgxRediCoreComponent
+  ],
+  imports: [
+  ],
+  exports: [
+    NgxRediCoreComponent
+  ]
+})
+export class NgxRediCoreModule { }

package/src/lib/ngx-redi-core.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { NgxRediCoreService } from './ngx-redi-core.service';
+
+describe('NgxRediCoreService', () => {
+  let service: NgxRediCoreService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(NgxRediCoreService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/ngx-redi-core.service.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class NgxRediCoreService {
+
+  constructor() { }
+}

package/src/public-api.ts

@@ -0,0 +1,7 @@
+/*
+ * Public API Surface of ngx-redi-core
+ */
+
+export * from './lib/ngx-redi-core.service';
+export * from './lib/ngx-redi-core.component';
+export * from './lib/ngx-redi-core.module';

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}