general-library-union 2.9.73 → 2.9.74

package/src/app/shared/utilidades/translate-loader.util.ts

@@ -0,0 +1,44 @@
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { TranslateLoader } from '@ngx-translate/core';
+
+import { Observable, from, of, switchMap } from 'rxjs';
+import { environment } from '../../../environments/environment';
+import { StorageService } from 'src/app/core/servicios/storage.service';
+import { AuthService } from 'src/app/core/servicios/auth.service';
+import { UtilsService } from 'src/app/core/servicios/utils.service';
+
+export class TranslateLoaderUtil implements TranslateLoader {
+  constructor(private http: HttpClient, 
+              private localStorage: StorageService,
+              private authService: AuthService,
+              public utilsService: UtilsService) {}
+
+  /**
+   * Consume el servicio para obtener las etiquetas de la aplicación
+   */
+  public getTranslation(lang: string): Observable<Object> {
+    return from(this.translationDetalle(lang));
+  }
+
+  async translationDetalle(lang: string): Promise<Observable<any>> {
+    console.log(this.utilsService.obtenerBase())
+    if (window.location.href.endsWith('not-found')) {
+      return null;
+    }
+    const url = `${environment.urlapisara}/authentication/inicio`;
+    let params = new HttpParams();
+    params = params.set('numeroAplicacion', environment.codigoAplicacion);
+    params = params.set('tipo', 'etiqueta');
+    
+    if (!this.localStorage.getItem('etiquetas')){
+      var tokenPublico = await this.authService.generarTokenPublico(environment.urlapisara).toPromise();
+      var headers = new HttpHeaders().set('Authorization', `Bearer ${tokenPublico.token}`)
+      var data = await this.http.get(url, { params: params, headers: headers }).toPromise()
+      this.localStorage.setItem('etiquetas', JSON.stringify((data as any).etiquetas))
+      return await ((data as any).etiquetas);
+    } else {
+      return await (this.localStorage.getItem('etiquetas') != null? JSON.parse(this.localStorage.getItem('etiquetas')) : {})
+    }
+
+  }
+}

package/src/app/webcommon/pages/cargue-plantilla/cargue-plantilla-general/cargue-plantilla-general.component.html

@@ -0,0 +1,167 @@
+<p-confirmPopup key="eliminarCarpeta"></p-confirmPopup>
+<p-confirmPopup key="eliminarArchivo"></p-confirmPopup>
+
+<h1 class="mb-4">{{'cargue' | translate}} {{'plantillas' | translate}}</h1>
+
+<div class="p-fluid p-formgrid grid">
+
+    <div class="field col-12 md:col-6 lg:col-5 card p-5">
+        <div class="flex justify-content-between align-items-center justify-content-center relative">
+            <input type="text" pInputText [(ngModel)]="filterValue" placeholder="{{'filtro' | translate}}"
+                (keydown)="filtrarEnter($event)" />
+            <button type="button" pButton pRipple icon="pi pi-search text-xl" (click)="aplicarFiltro()"
+                class="p-element p-ripple p-button-rounded  p-button-secondary p-button p-component p-button-icon-only absolute right-0 border-none bg-white-alpha-10"
+                tooltipPosition="bottom" pTooltip="Editar HTML"></button>
+        </div>
+
+        <p-tree #tree scrollHeight="670px" [value]="filteredFiles" selectionMode="single" [(selection)]="dataSelected"
+            [filter]="false" [filterPlaceholder]="'filtro' | translate" filterMode="strict"
+            (onNodeSelect)="seleccionarArchivo($event)" [loading]="loading"
+            (onNodeUnselect)="deseleccionarArchivo($event)"></p-tree>
+    </div>
+
+    <!-- OPCINES DIRECTORIOS - ARCHIVOS -->
+    <div class="field col-12 md:col-6 lg:col-7 p-0 pl-3">
+
+        @if(!this.loading){
+        <div class="card p-3">
+
+            <!-- CARPETA -->
+            @if(archivoSeleccionado.expanded){
+            <div class="flex align-items-center">
+                <h1 class="text-xl mt-2 mb-4 mr-3">Carpeta: </h1>
+                <h5 class="text-sm mt-2 mb-4"> {{archivoSeleccionado.label}} </h5>
+            </div>
+
+            <div class="flex justify-content-between">
+
+                <!-- Convertir -->
+                <button type="button" pButton pRipple (click)="convertirArchivos()"
+                    *ngIf="verConvertir && controlFuncionService.getControlFuncionalidad('seguplacor:guardar')"
+                    tooltipPosition="bottom" label="{{'convertir' | translate}}"
+                    class="p-button-outlined boton-accion-principal text-gray-600 color-500"
+                    pTooltip="Convertir archivo" tooltipPosition="bottom">
+                    <div class="contenedor-icono-acciones-principal">
+                        <i class="pi pi-arrow-right-arrow-left color-500"></i>
+                    </div>
+                </button>
+
+                <!--Nueva Carpeta-->
+                <button *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:guardar')" pButton pRipple
+                    class="p-button-outlined  boton-accion-principal text-gray-600 color-500"
+                    label="{{'link_nuevo' | translate}}" (click)="crearCarpeta()">
+                    <div class="contenedor-icono-acciones-principal">
+                        <i class="glyphicons glyphicons-floppy-save color-500"></i>
+                    </div>
+                </button>
+
+                <!--Eliminar-->
+                <button *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:guardar')" pButton pRipple
+                    class="p-button-outlined  boton-accion-principal text-gray-600 color-500"
+                    label="{{'link_eliminar' | translate}}" (click)="eliminarCarpeta()">
+                    <div class="contenedor-icono-acciones-principal">
+                        <i class="glyphicons glyphicons-bin color-500"></i>
+                    </div>
+                </button>
+
+                <!-- Cargar Archivo -->
+                <div [ngClass]="{ 'min-width-100': !verConvertir, 'min-width-20': verConvertir }">
+                    <p-fileUpload #fubauto mode="basic" [auto]="true" [customUpload]="true" chooseIcon="pi pi-paperclip"
+                        *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:guardar')"
+                        chooseLabel="{{'link_subirarchivos' | translate}}" (onSelect)="cargarNuevo($event, fubauto)">
+                        <div class="contenedor-icono-acciones-principal">
+                            <i class="pi pi-trash"></i>
+                        </div>
+                    </p-fileUpload>
+                </div>
+            </div>
+            }
+
+            <!-- ARCHIVO-->
+            @if(!archivoSeleccionado.expanded){
+
+            <div class="flex align-items-center">
+                <h1 class="text-xl mt-2 mb-4 mr-3">Archivo: </h1>
+                <h5 class="text-sm mt-2 mb-4"> {{archivoSeleccionado.label}} </h5>
+            </div>
+
+            <div class="flex justify-content-end">
+                @if(archivoSeleccionado.label.includes('.html')){
+
+                <!--EDITAR HTML-->
+                <button type="button" pButton pRipple icon="pi pi-code text-xl color-500" (click)="editarAction()"
+                    class="p-button-outlined  boton-accion-principal text-gray-600" label="Editar HTML">
+                </button>
+                }
+
+                <!-- DESCARGAR-->
+                <button pButton pRipple class="p-button-outlined  boton-accion-principal text-gray-600 color-500"
+                    label="{{'link_descargar' | translate}}" (click)="descargarAnexo()"
+                    *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:descargar')">
+                    <div class="contenedor-icono-acciones-principal">
+                        <i class="glyphicons glyphicons-download color-500"></i>
+                    </div>
+                </button>
+
+                <!--ELIMINAR-->
+                <button pButton pRipple class="p-button-outlined  boton-accion-principal text-gray-600 color-500"
+                    label="{{'link_eliminar' | translate}}" (click)="eliminarArchivo()"
+                    *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:guardar')">
+                    <div class="contenedor-icono-acciones-principal">
+                        <i class="glyphicons glyphicons-bin color-500"></i>
+                    </div>
+                </button>
+            </div>
+            }
+        </div>
+        }
+
+        @if(archivoSeleccionado.expanded && isVisualizarCrearCaperta){
+        <div class="card">
+
+            <h5 class="mt-2"><i class="glyphicons glyphicons-note"></i> Nueva carpeta</h5>
+
+            <form #miFormulario="ngForm">
+                <!-- campos -->
+                <div class="flex mb-3">
+                    <!-- Nombre -->
+                    <div class="w-full p-0 mb-0">
+                        <span class="p-float-label mr-2">
+                            <input pInputText id="id_numero_de_evento" [(ngModel)]="nomNuevaCarpeta" required
+                                name="nombreCarpeta">
+                            <label for="id_numero_de_evento">{{'nombre' | translate}} *</label>
+                        </span>
+                    </div>
+
+                    <div class="flex justify-content-end">
+                        <!--Guardar Carpeta-->
+                        <button pButton pRipple class="mr-2 p-button background-100 color-500"
+                            icon="glyphicons glyphicons-floppy-save" [label]="('link_guardar' | translate)"
+                            (click)="guardarCarpeta()">
+                        </button>
+                    </div>
+                </div>
+            </form>
+
+        </div>
+        }
+        <!-- EDITOR DE HTML -->
+        <div *ngIf="isHtml() && mostrarEditor">
+
+            <div class="flex justify-content-end align-items-center mb-3">
+                <!-- Botón guardar HTML -->
+                <button pButton pRipple label="{{'link_guardar' | translate }}" (click)="guardarHtml()"
+                    icon="glyphicons glyphicons-floppy-save" class="p-button-secondary"
+                    *ngIf="controlFuncionService.getControlFuncionalidad('seguplacor:guardar')"></button>
+            </div>
+
+            <p-editor id="editor" [style]="{ height: '500px' }" required [(ngModel)]="modificarHTML"
+                name="htmlPublicacion"></p-editor>
+
+        </div>
+    </div>
+</div>
+
+@if(isMostrarPopupConvertir){
+<app-popup-convertir-plantillas (regresar)="regresarPopupConvertir($event)"></app-popup-convertir-plantillas>
+}

package/src/app/webcommon/pages/cargue-plantilla/cargue-plantilla-general/cargue-plantilla-general.component.scss

@@ -0,0 +1,11 @@
+:host ::ng-deep .p-fluid .p-fileupload .p-button{
+    width: 100%;
+}
+
+:host ::ng-deep .min-width-20 {
+    min-width: 20%;
+}
+
+:host ::ng-deep .min-width-100 {
+    min-width: 30%;
+}

package/src/app/webcommon/pages/cargue-plantilla/cargue-plantilla-general/cargue-plantilla-general.component.ts

@@ -0,0 +1,425 @@
+import { CommonModule } from '@angular/common';
+import { Component, ViewChild } from '@angular/core';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { ConfirmationService, MenuItem, TreeNode } from 'primeng/api';
+import { ButtonModule } from 'primeng/button';
+import { InputTextModule } from 'primeng/inputtext';
+import { SplitButtonModule } from 'primeng/splitbutton';
+import { Tree, TreeModule } from 'primeng/tree';
+import { AuthService } from '../../../../core/servicios/auth.service';
+import { PlantillasService } from '../../../../webcommon/services/plantillas.service';
+import { CargarControlFuncionalidadService } from '../../../../core/servicios/cargar-control-funcionalidad.service';
+import { ConfirmPopupModule } from 'primeng/confirmpopup';
+import { FormsModule, NgForm } from '@angular/forms';
+import { FieldsetModule } from 'primeng/fieldset';
+import { FileUploadModule } from 'primeng/fileupload';
+import { ToastService } from '../../../../core/servicios/toast.service';
+import { CargarArchivosService } from '../../../../shared/servicios/cargar-archivos.service';
+import { EncriptadoBasicoService } from '../../../../shared/servicios/encriptado-basico.service';
+import { GeneralPipe } from '../../../../webcommon/pipes/general.pipe';
+import { PopupConvertirPlantillasComponent } from '../../../../webcommon/popups/popup-convertir-plantillas/popup-convertir-plantillas.component';
+import { UtilsService } from '../../../../core/servicios/utils.service';
+import { firstValueFrom } from 'rxjs';
+import { EditorModule } from 'primeng/editor';
+
+@Component({
+  selector: 'app-cargue-plantilla-general',
+  standalone: true,
+  imports: [TranslateModule,
+    CommonModule,
+    TreeModule,
+    InputTextModule,
+    ButtonModule,
+    SplitButtonModule,
+    ConfirmPopupModule,
+    FormsModule,
+    FieldsetModule,
+    FileUploadModule,
+    PopupConvertirPlantillasComponent,
+    EditorModule
+  ],
+  templateUrl: './cargue-plantilla-general.component.html',
+  styleUrl: './cargue-plantilla-general.component.scss',
+  providers: [
+    ConfirmationService
+  ]
+})
+export class CarguePlantillaGeneralComponent {
+
+  @ViewChild(PopupConvertirPlantillasComponent) popupConvertirPlantillasComponent: PopupConvertirPlantillasComponent;
+  @ViewChild('miFormulario', { static: false }) miFormulario!: NgForm;
+  @ViewChild('tree') treeComponent!: Tree;
+
+  loading: boolean;
+  propiedad: string;
+  extensiones: string;
+  propiedadDeSistema: boolean = false;
+  anexoPropiedad: string = '';
+  files: TreeNode[];
+  dataSelected: TreeNode;
+  itemsBotonAcciones: MenuItem[];
+  verConvertir: boolean;
+  nomNuevaCarpeta: string;
+  isVisualizarCrearCaperta: boolean = false;
+  archivoSeleccionadoAnexo: File;
+  archivoSeleccionado: TreeNode;
+  isMostrarPopupConvertir: boolean = false;
+  rutaPrincipal: string;
+  filteredFiles: TreeNode[] = [];
+  filterValue: string = '';
+
+  FORMATS_VALIDOS: Set<string> = new Set([
+    '.doc',
+    '.html',
+    '.jasper',
+    '.xls',
+    '.jrxml',
+    '.odt',
+    '.xlsm',
+    '.xlsx',
+    '.pgp',
+    '.asc',
+    '.cer',
+    '.p12',
+    '.docx',
+    '.properties'
+  ]);
+  filtroConvertir: string;
+  html: boolean;
+  mostrarEditor: boolean;
+  modificarHTML: string;
+
+  constructor(private plantillasService: PlantillasService, private authService: AuthService, public translateService: TranslateService,
+    public controlFuncionService: CargarControlFuncionalidadService, private confirmationService: ConfirmationService,
+    private toastService: ToastService, private cargarArchivoServices: CargarArchivosService, private encriptadoBasico: EncriptadoBasicoService,
+    private generalPipe: GeneralPipe, public utilsService: UtilsService
+  ) { }
+
+  async ngOnInit(): Promise<void> {
+
+    this.mostrarEditor = false;
+    let consultarRutaPrincipal = await firstValueFrom(this.cargarArchivoServices.getPropiedad({ propiedad: "ruta_plantillas", aplicacion: 1 }));
+    let convertir = await firstValueFrom(this.cargarArchivoServices.getPropiedad({ propiedad: "servidor_openOffice", aplicacion: 0 }));
+    this.verConvertir = !convertir.valor.valor ? true : false;
+    this.rutaPrincipal = consultarRutaPrincipal.valor.valor;
+    this.isVisualizarCrearCaperta = false;
+    await this.openDataTable();
+
+    const sleep = (m) => new Promise((r) => setTimeout(r, m));
+    await sleep(100);
+
+    if (this.filterValue) {
+      await this.aplicarFiltro();
+    }
+  }
+
+  async openDataTable() {
+
+    setTimeout(() => {
+      this.loading = true;
+
+      if (!this.propiedad) {
+        this.propiedad = 'ruta_plantillas'
+      }
+      this.plantillasService.obtenerArchivos(
+        this.propiedad, this.propiedadDeSistema ? '0' : this.authService.getTokenKey('aplicacion'), 'doc;html;jasper;xls;jrxml;odt;xlsm;xlsx;pgp;asc;cer;p12;docx;properties', this.anexoPropiedad, true).subscribe
+        (rta => {
+          this.files = rta;
+          this.filteredFiles = rta
+          this.loading = false;
+          if (!this.archivoSeleccionado) {
+            this.archivoSeleccionado = this.files[0];
+          }
+        });
+    }, 1000);
+  }
+
+  async aplicarFiltro() {
+    this.filtroConvertir = this.filterValue;
+    this.loading = true;
+    setTimeout(() => {
+      this.filteredFiles = this.obtenerFiltrosNodos(this.files, this.filterValue);
+      this.loading = false;
+    }, 1000);
+  }
+
+  obtenerFiltrosNodos(nodes: TreeNode[], filterValue: string): TreeNode[] {
+
+    const filters = this.filtroAvanzado(filterValue);
+
+    const filteredNodes: TreeNode[] = [];
+
+    nodes.forEach(node => {
+
+      // Verifica si el nodo actual o alguno de sus hijos cumple con el filtro
+      const children = node.children ? this.obtenerFiltrosNodos(node.children, filterValue) : [];
+
+      const nodeMatches = filters.some(filter => node.label.includes(filter));
+
+      if (nodeMatches || children.length > 0) {
+        filteredNodes.push({ ...node, children });
+      }
+    });
+
+    return filteredNodes;
+  }
+
+  filtroAvanzado(search: string): string[] {
+
+    if (search.includes('+')) {
+      let aux = search;
+
+      if (aux.startsWith('+')) {
+        aux = aux.substring(1);
+      }
+
+      aux = aux.replace(/\+/g, ':');
+      const items = aux.trim().split(':');
+      return items;
+
+    } else {
+      return [search];
+    }
+  }
+
+  filtrarEnter(event) {
+    if (event.key === 'Enter') {
+      this.aplicarFiltro();
+    }
+  }
+
+  seleccionarArchivo(event) {
+    this.archivoSeleccionado = event.node;
+    this.mostrarEditor = false;
+  }
+
+  deseleccionarArchivo($event) {
+    this.dataSelected = null;
+  }
+
+
+  async cargarNuevo(event, fubauto) {
+
+    this.isVisualizarCrearCaperta = false;
+    this.archivoSeleccionadoAnexo = event.files[0];
+
+    if (!this.isFormatoValido(this.archivoSeleccionadoAnexo.name)) {
+      this.toastService.showWarning("Se debe agregar un archivo " + Array.from(this.FORMATS_VALIDOS).join(', '))
+      fubauto.clear();
+      //this.toastService.showWarning("Se debe agregar un archivo .doc, .docx, .xls, .xlsx , .xlsm, .jrxml, .odt, .jasper, .pgp, .asc, .cer, .properties o .html");
+      return;
+    }
+
+    //Cargar Archivo Temporal
+    let resultado = await firstValueFrom(this.plantillasService.cargarDocumentoTemporal(this.archivoSeleccionadoAnexo));
+
+    fubauto.clear();
+
+    if (resultado?.validacion) {
+      this.toastService.showSuccess(resultado?.validacion);
+      return;
+    }
+
+    let informacionArchivo = resultado?.informacionArchivo ? resultado?.informacionArchivo : null;
+
+    //Obtener Rutas
+    let rutaComplemento = this.archivoSeleccionado.data;
+
+    //let objeto = (await this.cargarArchivoServices.getPropiedad({ propiedad: "ruta_plantillas", aplicacion: 1 }).toPromise());
+
+    if (!this.archivoSeleccionado?.parent) {
+      rutaComplemento = '';
+    }
+
+    //Verifica si el documento ya existe 
+    let data = await firstValueFrom(this.plantillasService.existeDocumento(this.rutaPrincipal, rutaComplemento, informacionArchivo));
+
+    if (data?.validacionDocumento) {
+      this.toastService.showWarning(data?.validacionDocumento);
+      return;
+    }
+
+    //Guarda el documento
+    await firstValueFrom(this.plantillasService.cargarDocumento(this.rutaPrincipal, rutaComplemento, informacionArchivo));
+
+    this.ngOnInit();
+
+  }
+
+  async descargarAnexo() {
+
+    //Ruta archivo  
+    let rutaComplemento = this.archivoSeleccionado.data;
+
+    if (!this.archivoSeleccionado?.parent) {
+      rutaComplemento = '';
+    }
+
+    this.cargarArchivoServices.descargarArchivo(this.encriptadoBasico.encriptar(this.rutaPrincipal + rutaComplemento), undefined, undefined).subscribe(blob => {
+      const a = document.createElement('a');
+      const objectUrl = URL.createObjectURL(blob);
+      a.href = objectUrl;
+      a.download = this.archivoSeleccionado?.label;
+      a.click();
+      URL.revokeObjectURL(objectUrl);
+    });
+
+  }
+
+  eliminarArchivo() {
+    this.confirmationService.confirm({
+      target: event.target,
+      key: 'eliminarArchivo',
+      message: '¿Desea eliminar el registro?',
+      acceptLabel: 'Si',
+      icon: 'confirmar',
+      accept: () => {
+        this.setEliminarArchivo();
+      },
+      reject: () => { },
+    });
+  }
+
+  async setEliminarArchivo() {
+
+    //Ruta archivo  
+    let rutaComplemento = this.archivoSeleccionado.data;
+
+    if (!this.archivoSeleccionado?.parent) {
+      rutaComplemento = '';
+    }
+
+    let propiedad = 'ruta_plantillas'
+    await firstValueFrom(this.cargarArchivoServices.eliminarArchivo(this.encriptadoBasico.encriptar(rutaComplemento), propiedad, '1'));
+    this.toastService.showSuccess(this.generalPipe.MENSAJE_ELIMINAR);
+    this.archivoSeleccionado = null;
+    this.filterValue = null;
+    this.ngOnInit();
+  }
+
+  isFormatoValido(nombreArchivo: string): boolean {
+    // Verifica si el archivo termina con alguna de las extensiones válidas
+    return Array.from(this.FORMATS_VALIDOS).some(ext => nombreArchivo.endsWith(ext));
+  }
+
+  crearCarpeta() {
+    this.isVisualizarCrearCaperta = true;
+    this.nomNuevaCarpeta = null;
+  }
+
+  async guardarCarpeta() {
+
+    if (this.miFormulario.valid) {
+
+      let rutaComplemento = this.archivoSeleccionado.data;
+
+      if (!this.archivoSeleccionado?.parent) {
+        rutaComplemento = '';
+      }
+
+      await firstValueFrom(this.plantillasService.crearCarpeta(this.rutaPrincipal, rutaComplemento, this.nomNuevaCarpeta));
+      this.toastService.showSuccess('La carpeta se ha creado correctamente');
+      this.ngOnInit();
+
+    } else {
+
+      this.toastService.showError('Faltan campos obligatorios');
+      Object.keys(this.miFormulario.controls).forEach((key) => {
+        if (this.miFormulario.controls[key].invalid) {
+          this.miFormulario.controls[key].markAsDirty();
+        }
+      });
+    }
+
+  }
+
+  eliminarCarpeta() {
+
+    this.isVisualizarCrearCaperta = false;
+
+    this.confirmationService.confirm({
+      target: event.target,
+      key: 'eliminarCarpeta',
+      message: '¿Desea eliminar el registro?',
+      acceptLabel: 'Si',
+      icon: 'confirmar',
+      accept: () => {
+        this.setEliminarCarpeta();
+      },
+      reject: () => { },
+    });
+  }
+
+  async setEliminarCarpeta() {
+
+    let rutaComplemento = this.archivoSeleccionado.data;
+
+    if (!this.archivoSeleccionado?.parent) {
+      rutaComplemento = '';
+    }
+
+    this.plantillasService.eliminarCarpeta(this.rutaPrincipal, rutaComplemento).subscribe(rta => {
+      this.toastService.showSuccess('La carpeta ha sido eliminada correctamente');
+      this.archivoSeleccionado = null;
+      this.filterValue = null;
+      this.ngOnInit();
+    })
+
+  }
+
+  async convertirArchivos() {
+
+    this.isVisualizarCrearCaperta = false;
+    this.isMostrarPopupConvertir = true;
+    //const filteredNodes = this.getFilteredNodes();
+    const valorFiltro = this.filterValue;
+
+    const sleep = (m) => new Promise((r) => setTimeout(r, m));
+    await sleep(50);
+
+    this.popupConvertirPlantillasComponent.buscar(this.rutaPrincipal, valorFiltro);
+
+  }
+
+  regresarPopupConvertir($event: any) {
+    this.isMostrarPopupConvertir = false;
+    this.ngOnInit();
+  }
+
+  isHtml() {
+    this.html = false;
+
+    if (this.archivoSeleccionado != null && this.archivoSeleccionado.label != null && this.archivoSeleccionado.label.includes('.html'))
+      this.html = true;
+
+    return this.html;
+  }
+
+  async editarAction() {
+
+    let data = await firstValueFrom(this.plantillasService.consultarArchivoHtml(this.rutaPrincipal, this.archivoSeleccionado.data));
+
+    this.modificarHTML = data;
+
+    this.mostrarEditor = true;
+  }
+
+  async guardarHtml() {
+
+    await firstValueFrom(this.plantillasService.guardarArchivoHtml(this.rutaPrincipal, this.archivoSeleccionado.data, this.modificarHTML));
+
+    this.toastService.showSuccess('El archivo ha sido modificado correctamente');
+
+    this.ngOnInit();
+
+  }
+
+  regresarPrincipal() {
+    this.mostrarEditor = false;
+  }
+
+  public verificarControl(control) {
+    return this.controlFuncionService.getControlFuncionalidad(control);
+  }
+
+}