general-library-union 3.0.43 → 3.0.45

package/src/app/webcommon/pages/ejecucion-reporte/detalle-tipo-reporte/detalle-tipo-reporte.component.ts

@@ -0,0 +1,1694 @@
+import { Component, OnInit, Input, OnDestroy } from '@angular/core';
+import { FormBuilder, FormControl, FormGroup, FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
+import { GeneralPipe } from '../../../pipes/general.pipe';
+import { GeneralService } from '../../../../shared/servicios/general.service';
+import { GeneralModel } from '../../../../seguridad/modelos/GeneralModel';
+import { CargarArchivosService } from '../../../../shared/servicios/cargar-archivos.service';
+import { EncriptadoBasicoService } from '../../../../shared/servicios/encriptado-basico.service';
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { Subscription } from 'rxjs';
+
+import { ReporteFuentePipe } from '../../../pipes/reporte-fuente.pipe';
+import { EjecucionReporteService } from '../../../services/ejecucionreporte.service';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { FuentePipe } from '../../../pipes/fuente.pipe';
+import { ReporteColumnarioPipe } from '../../../pipes/reporte-columnario.pipe';
+import { ReporteColumnaModel } from '../../../../seguridad/modelos/ReporteColumna';
+import { ReporteMarcadorModel } from '../../../../seguridad/modelos/ReporteMarcador';
+import { ReporteTablaModel } from '../../../../seguridad/modelos/ReporteTabla';
+import { ReporteColumnarioModel } from '../../../../seguridad/modelos/ReporteColumnario';
+import { ReporteFuenteModel } from '../../../../seguridad/modelos/ReporteFuenteModel';
+import { ReporteColumnarioMarcadorModel } from '../../../../seguridad/modelos/ReporteColumnarioMarcador';
+import { ReporteBandaModel } from '../../../../seguridad/modelos/ReporteBanda';
+import { ReporteSoporteModel } from '../../../../seguridad/modelos/ReporteSoporte';
+import { ToastService } from '../../../../core/servicios/toast.service';
+import { UtilsService } from '../../../../core/servicios/utils.service';
+import { AuthService } from '../../../../core/servicios/auth.service';
+import { TableModule } from 'primeng/table';
+import { TabViewModule } from 'primeng/tabview';
+import { InputHelperSeleccionPlantillaComponent } from '../../../../shared/componentes/input-helper-seleccion-plantilla/input-helper-seleccion-plantilla.component';
+import { DropdownModule } from 'primeng/dropdown';
+import { CommonModule } from '@angular/common';
+import { ButtonModule } from 'primeng/button';
+import { PickListModule } from 'primeng/picklist';
+import { FieldsetModule } from 'primeng/fieldset';
+import { AccordionModule } from 'primeng/accordion';
+import { InputTextModule } from 'primeng/inputtext';
+import { InputTextareaModule } from 'primeng/inputtextarea';
+import { FloatLabelModule } from 'primeng/floatlabel';
+import { InputNumberModule } from 'primeng/inputnumber';
+import { DashboardService } from '../../../services/dashboard.service';
+import { ChartModule } from 'primeng/chart';
+import { DashboardPipe } from '../../../pipes/dashboard.pipe';
+import { ColorPickerModule } from 'primeng/colorpicker';
+
+@Component({
+  selector: 'detalle-tipo-reporte',
+    imports: [TranslateModule, TableModule, TabViewModule, InputHelperSeleccionPlantillaComponent, ReporteColumnarioPipe, ReporteFuentePipe, DropdownModule, FormsModule, ReactiveFormsModule, CommonModule, ButtonModule, PickListModule, FieldsetModule, AccordionModule, InputTextModule, InputTextareaModule, FloatLabelModule, InputNumberModule, FieldsetModule, ChartModule, ColorPickerModule], 
+    standalone: true,
+    providers: [MessageService],
+    templateUrl: './detalle-tipo-reporte.component.html',
+  styleUrls: ['./detalle-tipo-reporte.component.scss']
+})
+export class DetalleTipoReporteComponent implements OnInit, OnDestroy {
+
+  public listaTipoCifrado: any[] = [];
+  //tab excel
+  public listaExcel: ReporteColumnaModel[] = [];
+  public listaNoExcel: ReporteColumnaModel[] = [];
+  public listaMarcadorExcel: ReporteMarcadorModel[] = [];
+  public reporteMarcadorExcel: ReporteMarcadorModel = new ReporteMarcadorModel;
+  public formMarcadorExcel: FormGroup;
+  public verNuevoMarcadorExcel: boolean = false;
+  public esMarcador: boolean = false;
+  public esImagenFija: boolean = false;
+
+  //tab plantillas
+  public listaColumnas: any[] = [];
+  public listaMarcadores: ReporteMarcadorModel[] = [];
+  public listaTipoMarcador;
+  public listaTipoGrafico_JFC;
+  public listaGrafico;
+  public listaGraficoSencillo;
+  public listaAlineacion;
+  public listaOperaciones;
+  public reporteMarcador: ReporteMarcadorModel = new ReporteMarcadorModel;
+  public formMarcador: FormGroup;
+  public origenMarcador: string = null;
+  public verNuevoMarcador: boolean = false;
+  public listaCamposMarcador: ReporteTablaModel[] = [];
+  public campoMarcadorInsertar: ReporteTablaModel = new ReporteTablaModel;
+  public listaSoportes: ReporteSoporteModel[] = [];
+  public soporteIngresar: ReporteSoporteModel = new ReporteSoporteModel;
+  public clickGuardarMarcadorCampo: boolean = false
+  public clickGuardarMarcadorExcel: boolean = false;
+  public verReporteMarcadorDetalle: boolean = false;
+  public verSoporteArchivoDetalle: boolean = false;
+  public clickGuardarSoporteArchivo: boolean = false;
+  public habilitaCampo: boolean = false;
+
+  public bloquearCampoMarcador: boolean = false;
+  public bloquearSoporte: boolean = false;
+
+
+  //reporte dinamico
+  public listaTipoBanda = [
+    {key: 'banda1', value: 'Banda 1'},
+    {key: 'banda2', value: 'Banda 2'},
+    {key: 'banda3', value: 'Banda 3'},
+    {key: 'banda4', value: 'Banda 4'},
+    {key: 'banda5', value: 'Banda 5'},
+    {key: 'detalle', value: 'Detalle'},
+    {key: 'summary', value: 'Resumen'},
+  ]
+  public existeJasper: boolean = false;
+  public bandaSeleccionada = {key: null, value: null};
+  public nuevaBanda: boolean = false;
+  public verTabBanda: boolean = false;
+  public nuevoReporteMarcadorDinamico: boolean = false;
+  public reporteMarcadorDinamico: ReporteMarcadorModel = new ReporteMarcadorModel;
+  public reporteBanda: ReporteBandaModel = new ReporteBandaModel;
+  public formReporteDinamico: FormGroup;
+  public listaMarcadorDinamico: ReporteMarcadorModel[] = []
+  public listaTipoCampoJasperDinamico = [
+    {key: 'C', value: 'Calculo'},
+    {key: 'T', value: 'Columna'},
+  ]
+  public listaTipoDatoSintaxis = [
+    {key: 'F', value: 'Fecha'},
+    {key: 'N', value: 'Numero'},
+    {key: 'T', value: 'Texto'},
+  ]
+
+  //reporte tabla
+  public listaTabla: ReporteColumnaModel[] = [];
+  public listaNoTabla: ReporteColumnaModel[] = [];
+  
+
+  //reporte texto
+  public listaSeparadores;
+  public clickGuardarReporteTexto: boolean = false;
+  public listaMarcadoresTexto: ReporteMarcadorModel[] = [];
+  public marcadorTexto: ReporteMarcadorModel = new ReporteMarcadorModel()
+  public verNuevoMarcadorTexto: boolean = false;
+  public listaTipoMarcadorTexto;
+  public clickGuardarMarcadorTexto: boolean = false
+
+  //reporte XML
+  public listaTipoMarcadorXML;
+  public listaXML: ReporteMarcadorModel[] = []
+  public marcadorXML: ReporteMarcadorModel = new ReporteMarcadorModel
+  public clickGuardarMarcadorXML: boolean = false;
+  public verNuevoMarcadorXML: boolean = false;
+  public listaCamposMarcadorXML: ReporteTablaModel[] = [];
+  public campoMarcadorInsertarXML: ReporteTablaModel = new ReporteTablaModel;
+  public verReporteMarcadorDetalleXML: boolean = false;
+  public clickGuardarMarcadorCampoXML: boolean = false;
+
+  //reporte columnario
+  public listaReporteColumnario: ReporteColumnarioModel[] = [];
+  public verNuevoReporteColumnario: boolean = false;
+  public columnaBasica: ReporteColumnarioModel;
+  public clickGuardarReporteColumnario: boolean = false;
+  public listaTipoColumnas;
+  public listaOperacionesColumnario;
+  public listaOperacionesExcelColumnario;
+  public listaOrdenamiento;
+
+  public verNuevoColumnaAdicional: boolean = false;
+  public clickGuardarColumnaAdicional: boolean = false;
+  public columnasAdicionales: ReporteColumnarioModel[] = [];
+  public columnaAdicional: ReporteColumnarioModel;
+
+  public listaTipoMarcadorColumnario;
+  public verNuevoMarcadorColumnario: boolean = false;
+  public clickGuardarMarcadorColumnario: boolean = false;
+  public marcadoresColumnario: ReporteColumnarioMarcadorModel[] = [];
+  public marcadorColumnario: ReporteColumnarioMarcadorModel;
+
+  //grafica
+  public listaTipoGrafico;
+  public paginadorColumnas: ReporteColumnaModel[] = [];
+  public paginadorColoresGrafica: ReporteBandaModel[] = [];
+  public colorCategoria: ReporteBandaModel = new ReporteBandaModel();
+  public verColorCategoriaDetalle: boolean = false;
+  public clickGuardarColorCategoria: boolean = false;
+  public grafica;
+  public tipoGrafica: "bar" | "line" | "scatter" | "bubble" | "pie" | "doughnut" | "polarArea" | "radar";
+
+  public reporteFuente : ReporteFuenteModel = new  ReporteFuenteModel();
+  public llaveEmpresa: string;
+  public listaSiNo;
+  @Input() public llaveReporte : string;
+  @Input() public aplicacion : string;
+  @Input()  public listaFuentes: any[] = [];
+
+  _subsciprtions: Subscription[] = [];
+
+  constructor(private formBuilder: FormBuilder,
+    private notificacionesBusService: ToastService,
+    private generalService: GeneralService,
+    private generalPipe: GeneralPipe,
+    private authService: AuthService,
+    private reporteFuentePipe: ReporteFuentePipe,
+    private confirmationService: ConfirmationService,
+    private cargarArchivo: CargarArchivosService,
+    private encriptadorArchivo: EncriptadoBasicoService,
+    public utilsService: UtilsService,
+    private translateService: TranslateService,
+    private fuentePipe: FuentePipe,
+    private reporteColumnarioPipe: ReporteColumnarioPipe,
+    private reporteService: EjecucionReporteService,
+    private dashboardService: DashboardService,
+    private dashboardPipe: DashboardPipe,) {
+    }
+
+  ngOnInit(): void {
+    this.aplicacion = this.authService.getTokenKey('aplicacion')
+    this.llaveEmpresa = this.authService.getTokenKey('llaveEmpresa');
+    this.listaSiNo = this.generalPipe.LISTA_SINO;
+    this.listaTipoMarcadorColumnario = this.reporteColumnarioPipe.MAPA_TIPO_MARCADOR;
+    this.listaTipoColumnas = this.reporteColumnarioPipe.MAPA_TIPO_COLUMNAS;
+    this.listaOperacionesColumnario = this.reporteColumnarioPipe.MAPA_OPERACIONES_COLUMNARIO;
+    this.listaOperacionesExcelColumnario = this.reporteColumnarioPipe.MAPA_OPERACIONES_COLUMNARIO_EXCEL;
+    this.listaOrdenamiento = this.reporteColumnarioPipe.MAPA_ORDENAMIENTO;
+    this.listaSeparadores =  this.fuentePipe.LISTA_SEPARADORES;
+    this.listaTipoMarcador = this.reporteFuentePipe.LISTA_MARCADORES;
+    this.listaTipoGrafico_JFC = this.reporteFuentePipe.LISTA_TIPO_GRAFICO_JFC;
+    this.listaGrafico = this.reporteFuentePipe.LISTA_RECURSO_GRAFICA;
+    this.listaGraficoSencillo = this.reporteFuentePipe.RECURSO_GRAFICA;
+    this.listaAlineacion = this.reporteFuentePipe.LISTA_ALINEACION;
+    this.listaOperaciones = this.generalPipe.MAPAOPERACIONES;
+    this.listaTipoMarcadorTexto = this.reporteFuentePipe.TIPOMARCADORESTEXTO;
+    this.listaTipoMarcadorXML = this.reporteFuentePipe.LISTA_MARCADORES_XML;
+    this.listaTipoGrafico = this.reporteFuentePipe.LISTA_TIPO_GRAFICO;
+    this.cargar();
+    this.cargarFormMarcadorExcel();
+    this.cargarFormMarcador();
+    this.cargarFormDinamico();
+    this.agregarSubscripciones();
+    //this.cargarListas();
+
+  }
+
+  ngOnDestroy(){
+    this._subsciprtions.forEach((sub) => {
+      sub.unsubscribe();
+    });
+  }
+
+  agregarSubscripciones() {
+    this._subsciprtions.push(
+      this.formMarcadorExcel.get('tipo').valueChanges.subscribe((value) => {
+        const textoRegistroControl = this.formMarcadorExcel.get('textoRegistro');
+        const origenControl = this.formMarcadorExcel.get('origen');
+        if (!value){
+          this.esImagenFija = true;
+          this.esMarcador = true;
+          origenControl.clearValidators();
+          textoRegistroControl.clearValidators();
+        } else if (['MA'].includes(value)) {
+          this.esImagenFija = false;
+          this.esMarcador = true;
+          textoRegistroControl.setValidators(Validators.required);
+          origenControl.clearValidators();
+        } else if (['IF'].includes(value)) {
+          this.esImagenFija = true;
+          this.esMarcador = false;
+          origenControl.setValidators(Validators.required);
+          textoRegistroControl.setValidators(Validators.required);
+        }
+        textoRegistroControl.updateValueAndValidity();
+        origenControl.updateValueAndValidity();
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formMarcador.get('tipo').valueChanges.subscribe((value) => {
+        console.log('entra a tipo: ')
+        console.log(value)
+        this.formMarcador.clearValidators();
+        this.reporteMarcador.tipo = value;
+        if (this.reporteMarcador.tipo == this.reporteFuentePipe.MARCADORTABLA){
+         // this.reporteMarcador.tieneSql = 'N'
+         // this.formMarcador.get('tieneSql').setValue('N')
+        }
+        this.formMarcador.updateValueAndValidity();
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formMarcador.get('origen').valueChanges.subscribe((value) => {
+        this.formMarcador.clearValidators();
+        this.reporteMarcador.origen = value;
+        this.formMarcador.updateValueAndValidity();
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formMarcador.get('tieneSql').valueChanges.subscribe((value) => {
+        console.log('entra a tieneSql: ')
+        console.log(value)
+        this.formMarcador.clearValidators();
+        this.reporteMarcador.tieneSql = value;
+        this.formMarcador.updateValueAndValidity();
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formMarcador.get('tipoGrafico').valueChanges.subscribe((value) => {
+        this.formMarcador.clearValidators();
+        this.reporteMarcador.tipoGrafico = value;
+        this.formMarcador.updateValueAndValidity();
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formMarcadorExcel.get('origen').valueChanges.subscribe((value) => {
+        if (['U'].includes(value)) {
+          this.reporteMarcadorExcel.origen = 'U'
+        } else if (['C'].includes(value)) {
+          this.reporteMarcadorExcel.origen = 'C'        
+        }
+      })
+    );
+
+    this._subsciprtions.push(
+      this.formReporteDinamico.get('tipoCampo').valueChanges.subscribe((value) => {
+        this.reporteMarcadorDinamico.tipoCampo = value;
+        const resultadoXControl = this.formReporteDinamico.get('resultadoX');
+        const resultadoYControl = this.formReporteDinamico.get('resultadoY');  
+        if (this.bandaSeleccionada.key != 'detalle') {
+          resultadoXControl.setValidators(Validators.required);
+          resultadoYControl.setValidators(Validators.required);
+        } else {
+          resultadoXControl.clearValidators();
+          resultadoYControl.clearValidators();
+        } 
+        
+        const marcadorControl = this.formReporteDinamico.get('marcador');
+        const filtroControl = this.formReporteDinamico.get('filtro');
+        const tipoDatoControl = this.formReporteDinamico.get('tipoDato');
+        if (this.reporteMarcadorDinamico.tipoCampo == 'T') {
+          marcadorControl.setValidators(Validators.required);
+          filtroControl.clearValidators();
+          tipoDatoControl.clearValidators();
+        } else {
+          marcadorControl.clearValidators();
+          filtroControl.setValidators(Validators.required);
+          tipoDatoControl.setValidators(Validators.required);
+        }
+        marcadorControl.updateValueAndValidity();
+        filtroControl.updateValueAndValidity();
+        tipoDatoControl.updateValueAndValidity();
+         resultadoXControl.updateValueAndValidity();
+         resultadoYControl.updateValueAndValidity();
+      }),
+      this.formReporteDinamico.get('tipoDato').valueChanges.subscribe((value) => {
+        this.reporteMarcadorDinamico.tipoDato = value
+      })
+    );
+  }
+
+  cambiarTab(event){
+    switch (event.index) {
+      case 0:
+        this.cargar();
+        this.cargarListasExcel();
+        break;
+      case 1:
+        this.cargarListaMarcadores();
+        if (this.reporteFuente.unicoArchivo == 'N'){
+          this.cargarListaSoportes();
+        }
+        break;
+      case 2:
+        this.validarExisteJasper();
+        break;
+      case 3:
+        this.cargarListaMarcadoresTexto();
+        break;
+      case 4:
+        this.cargarListasTabla();
+        break;
+      case 5:
+        this.cargarListaXML();
+        break;
+      case 6:
+        this.cargarReporteColumnario();
+        break;
+      case 7:
+        this.cargarGraficasColumnas();
+        break;
+      default:
+        break;
+    }
+  }
+
+  cargarListasTabla(){
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {buscarOrdenTabla: 'S', ordenarTabla: 'S', reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.listaTabla = data;
+    })
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {buscarOrdenTabla: 'N', reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.listaNoTabla = data;
+    })
+  }
+
+  cargarListaMarcadores(){
+    this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {tipoReporte: 'P', reporteFuente: this.reporteFuente.llave, ordenDinamico: this.generalPipe.SI})).subscribe(data => {
+      this.listaMarcadores = data;
+    })    
+  }
+
+  cargarListasExcel(){
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {ordenExcel: 'S', reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.listaExcel = data;
+    })
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {ordenExcel: 'N', reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.listaNoExcel = data;
+    })
+    this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {tipoReporte: 'E', reporteFuente: this.reporteFuente.llave, ordenDinamico: this.generalPipe.SI})).subscribe(data => {
+      this.listaMarcadorExcel = data;
+    })
+  }
+
+  cargarListaColumnas(){
+    this.listaColumnas = [];
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.listaColumnas = data;
+    })
+  }
+
+  cargarListas(){
+    this.listaTipoCifrado = [];
+    this.generalService.queryForList(new GeneralModel('EncripcionArchivoDTO', null, false, {})).subscribe(data => {
+      this.listaTipoCifrado = data;
+    })
+    this.cargarListaColumnas();
+  }
+
+  cargarFormMarcadorExcel(){
+    this.formMarcadorExcel = this.formBuilder.group({
+      descripcion: new FormControl(this.reporteMarcadorExcel.descripcion, [Validators.required, Validators.maxLength(100)]),
+      marcador: new FormControl(this.reporteMarcadorExcel.marcador, [Validators.required, Validators.maxLength(50)]),
+      tipo: new FormControl(this.reporteMarcadorExcel.tipo, [Validators.required]),
+      textoRegistro: new FormControl(this.reporteMarcadorExcel.textoRegistro),
+      origen: new FormControl(this.reporteMarcadorExcel.origen),
+      //campos bd
+      llave: new FormControl(this.reporteMarcadorExcel.llave),
+      reporteFuente: new FormControl(this.reporteFuente.llave),
+      tipoReporte: new FormControl('E') 
+    })
+  }
+
+  cargarFormMarcador(){
+    this.formMarcador = this.formBuilder.group({
+      descripcion: new FormControl(this.reporteMarcador.descripcion, [Validators.required, Validators.maxLength(100)]),
+      tipo: new FormControl(this.reporteMarcador.tipo, [Validators.required]),
+      marcador: new FormControl(this.reporteMarcador.marcador, [Validators.maxLength(50)]),
+      tabla: new FormControl(this.reporteMarcador.tabla),
+      origen: new FormControl(this.reporteMarcador.origen),
+      textoRegistro: new FormControl(this.reporteMarcador.textoRegistro),
+      reporteColumna: new FormControl(this.reporteMarcador.reporteColumna),
+      formato: new FormControl(this.reporteMarcador.formato),
+      ancho: new FormControl(this.reporteMarcador.ancho),
+      alto: new FormControl(this.reporteMarcador.alto),
+      grupo1: new FormControl(this.reporteMarcador.grupo1),
+      grupo2: new FormControl(this.reporteMarcador.grupo2),
+      grupo3: new FormControl(this.reporteMarcador.grupo3),
+      finalGrupo: new FormControl(this.reporteMarcador.finalGrupo),
+      tieneSql: new FormControl(this.reporteMarcador.tieneSql),
+      query: new FormControl(this.reporteMarcador.query),
+      fuente: new FormControl(this.reporteMarcador.fuente),
+      tipoGrafico: new FormControl(this.reporteMarcador.tipoGrafico),
+      marcadorGrafico: new FormControl(this.reporteMarcador.marcadorGrafico),
+      titulox: new FormControl(this.reporteMarcador.titulox),
+      tituloy: new FormControl(this.reporteMarcador.tituloy),
+      banda: new FormControl(this.reporteMarcador.banda),
+      anchoJasperLabel: new FormControl(this.reporteMarcador.anchoJasperLabel),
+      filtro: new FormControl(this.reporteMarcador.filtro),
+      //campos bd
+      llave: new FormControl(this.reporteMarcador.llave),
+      reporteFuente: new FormControl(this.reporteFuente.llave),
+      tipoReporte: new FormControl('N') 
+    })
+  }
+
+  cargarFormDinamico(){
+    this.formReporteDinamico = this.formBuilder.group({
+      tipoCampo: new FormControl(this.reporteMarcadorDinamico.tipoCampo, [Validators.required]),
+      tipoDato: new FormControl(this.reporteMarcadorDinamico.tipoDato),
+      filtro: new FormControl(this.reporteMarcadorDinamico.filtro),
+      marcador: new FormControl(this.reporteMarcadorDinamico.marcador),
+      alto: new FormControl(this.reporteMarcadorDinamico.alto, [Validators.required]),
+      formato: new FormControl(this.reporteMarcadorDinamico.formato),
+      descripcion: new FormControl(this.reporteMarcadorDinamico.descripcion),
+      ancho: new FormControl(this.reporteMarcadorDinamico.ancho, [Validators.required]),
+      anchoJasperLabel: new FormControl(this.reporteMarcadorDinamico.anchoJasperLabel),
+      resultadoX: new FormControl(this.reporteMarcadorDinamico.resultadoX ),
+      resultadoY: new FormControl(this.reporteMarcadorDinamico.resultadoY ),
+      titulox: new FormControl(this.reporteMarcadorDinamico.titulox),
+      tituloy: new FormControl(this.reporteMarcadorDinamico.tituloy),
+      tipoReporte: new FormControl(this.reporteMarcadorDinamico.tipoReporte, [Validators.required]),
+      tipoGrafico: new FormControl(this.reporteMarcadorDinamico.tipoGrafico),      
+      operacion: new FormControl(this.reporteMarcadorDinamico.operacion),      
+      //campos tabla
+      origen: new FormControl('D'),
+      banda: new FormControl(this.bandaSeleccionada.key),
+      reporteFuente: new FormControl(this.reporteFuente.llave),
+      llave: new FormControl(this.reporteMarcadorDinamico.llave),
+
+    })
+  }
+
+  cargar(){
+    this.existeJasper = false;
+      if (this.llaveReporte){
+        this.generalService.queryForObject(new GeneralModel('ReporteFuenteDTO', null, false, {llave: this.llaveReporte})).subscribe(data => {
+          this.reporteFuente = data;
+          this.cargarListasExcel();
+          this.cargarListas();
+        })
+      }
+  }
+
+  public actualizar(){
+    if (this.reporteFuente.llave){
+      this.generalService.update(new GeneralModel('ReporteFuenteDTO', null, false, this.reporteFuente)).subscribe(data => {
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+        if (this.reporteFuente.unicoArchivo == 'N'){
+        }
+      });
+    } else {
+      this.reporteService.guardarReporte(this.reporteFuente).subscribe(data => {
+        this.reporteFuente = data;
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+      });
+    }
+  }
+
+  obtenerArchivo(event){
+    this.reporteFuente.archivoTodo = event.data
+  }
+
+  obtenerArchivoMarcadorExcel(event){
+    this.reporteMarcador.textoRegistro = event.data
+  }
+
+  obtenerArchivoMarcador(event){
+    this.reporteMarcador.textoRegistro = event.data
+  }
+
+  obtenerArchivoPlanilla(event){
+    this.reporteFuente.archivoIndividual = event.data
+  }
+
+  obtenerArchivoSoporte(event, soporte){
+    soporte.archivoIndividual = event.data
+  }
+
+  obtenerArchivoColumnario(event){
+    this.reporteFuente.archivoExcelColumnario = event.data
+  }
+
+
+  moverAAsociado(event){
+    this.reporteService.actualizarReporteColumnaOrden({
+      listaAsociado: this.listaExcel,
+      excel: true
+    }).subscribe(data => {this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR_VARIOS)})
+  }
+
+  moverADesasociado(event){
+    this.reporteService.actualizarReporteColumnaOrden({
+      listaDesasociado: this.listaNoExcel,
+      excel: true
+     }).subscribe(data => {this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR_VARIOS)})
+  }
+
+  moverAAsociadoTabla(event){
+    this.reporteService.actualizarReporteColumnaOrden({
+      listaAsociado: this.listaTabla,
+      excel: false
+    }).subscribe(data => {this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR_VARIOS)})
+  }
+
+  moverADesasociadoTabla(event){
+    this.reporteService.actualizarReporteColumnaOrden({
+      listaDesasociado: this.listaNoTabla,
+      excel: false
+     }).subscribe(data => {this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR_VARIOS)})
+  }
+
+  reorderTabla(event){
+    this.reporteService.actualizarReporteColumnaOrden({
+      listaAsociado: this.listaTabla,
+      excel: false
+     }).subscribe(data => {this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR_VARIOS)})
+  }
+
+  verDetalleMarcadorExcel(event){
+    this.formMarcadorExcel.reset();
+    this.verNuevoMarcadorExcel = true;
+    this.reporteMarcadorExcel = event.data;
+    this.formMarcadorExcel.patchValue(this.reporteMarcadorExcel)
+  }
+
+  nuevoMarcadorExcel(){
+    this.formMarcadorExcel.reset();
+    this.verNuevoMarcadorExcel = true;
+    this.esMarcador = false;
+    this.esImagenFija = false;
+    this.reporteMarcadorExcel = new ReporteMarcadorModel();
+    this.formMarcadorExcel.patchValue(this.reporteMarcadorExcel)
+    this.formMarcadorExcel.get('tipo').setValue(null)
+  }
+
+  guardarMarcadorExcel(){
+    this.clickGuardarMarcadorExcel = true;
+    if (this.formMarcadorExcel.valid){
+      let llaveRegistro =  this.formMarcadorExcel.get('llave').value
+      this.formMarcadorExcel.get('reporteFuente').setValue(this.reporteFuente.llave)
+      this.formMarcadorExcel.get('tipoReporte').setValue('E')
+      if (llaveRegistro){
+        this.generalService.update(new GeneralModel('ReporteMarcadorDTO', null, false, this.formMarcadorExcel.value)).subscribe( data => {
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+          this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {tipoReporte: 'E', reporteFuente: this.reporteFuente.llave, ordenDinamico: this.generalPipe.SI})).subscribe(data => {
+            this.listaMarcadorExcel = data;
+          })
+        })
+      } else {
+        this.formMarcadorExcel.get('llave').setValue(this.utilsService.generarLlave())
+        this.generalService.crearRegistro(new GeneralModel('ReporteMarcadorDTO', null, false, this.formMarcadorExcel.value)).subscribe( data => {  
+          this.verNuevoMarcadorExcel = false      
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+          this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {tipoReporte: 'E', reporteFuente: this.reporteFuente.llave, ordenDinamico: this.generalPipe.SI})).subscribe(data => {
+            this.listaMarcadorExcel = data;
+          })
+        })
+      }
+      this.clickGuardarMarcadorExcel = false;
+    } else {
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      Object.keys(this.formMarcadorExcel.controls).forEach((key) => {
+        if (this.formMarcadorExcel.get(key).errors) {
+          this.formMarcadorExcel.get(key).markAsDirty();
+        }
+      });
+    } 
+  }
+
+  eliminarMarcadorExcel(event){
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteMarcadorDTO', null, false, this.reporteMarcadorExcel)).subscribe(data =>{
+          this.formMarcadorExcel.reset();
+          this.verNuevoMarcadorExcel = false;
+          this.reporteMarcadorExcel = new ReporteMarcadorModel();
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR)
+          this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {tipoReporte: 'E', reporteFuente: this.reporteFuente.llave, ordenDinamico: this.generalPipe.SI})).subscribe(data => {
+            this.listaMarcadorExcel = data;
+          })
+        })
+      }
+    })
+    
+  }
+
+  //plantilla
+
+  cargarListaCampoMarcador() {
+    this.generalService.queryForList(new GeneralModel('ReporteTablaDTO', null, false, { reporteMarcador: this.reporteMarcador.llave})).subscribe(data => {
+      this.listaCamposMarcador = data;
+    })
+  }
+
+  async cargarListaCampoMarcadorAsync() {
+    this.bloquearCampoMarcador = false;
+    this.listaCamposMarcador = await this.generalService.queryForList(new GeneralModel('ReporteTablaDTO', null, false, { reporteMarcador: this.reporteMarcador.llave})).toPromise();
+  }
+
+  verDetalleMarcador(event){
+    //this.formMarcador.reset();
+    this.verNuevoMarcador = true;
+    this.reporteMarcador = event.data;
+    this.formMarcador.patchValue(this.reporteMarcador)
+    this.formMarcador.get('tipo').setValue(this.reporteMarcador.tipo)
+    
+    this.cargarListaCampoMarcador();
+  }
+
+  nuevoMarcador(){
+    //this.formMarcador.reset();
+    this.formMarcador.reset({}, { emitEvent: false });
+
+    this.verNuevoMarcador = true;
+    this.reporteMarcador = new ReporteMarcadorModel();
+    this.formMarcador.patchValue(this.reporteMarcador)
+    this.formMarcador.get('tipoReporte').setValue('P')
+    //this.formMarcador.get('tipo').setValue(null)
+  }
+
+  guardarMarcador(){
+    if (this.formMarcador.valid){
+      let llaveRegistro =  this.formMarcador.get('llave').value
+      this.formMarcador.get('reporteFuente').setValue(this.reporteFuente.llave)
+      //this.formMarcador.get('tipoReporte').setValue('N')
+      if (llaveRegistro){
+        this.generalService.update(new GeneralModel('ReporteMarcadorDTO', null, false, this.formMarcador.value)).subscribe( data => {
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+          this.cargarListaMarcadores();
+          if (this.reporteFuente.unicoArchivo == 'N'){
+            this.cargarListaSoportes();
+          }
+        })
+      } else {
+        this.formMarcador.get('llave').setValue(this.utilsService.generarLlave())
+        this.generalService.crearRegistro(new GeneralModel('ReporteMarcadorDTO', null, false, this.formMarcador.value)).subscribe( data => {          
+          this.verNuevoMarcador = false;
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+          this.cargarListaMarcadores();
+          if (this.reporteFuente.unicoArchivo == 'N'){
+            this.cargarListaSoportes();
+          }
+        })
+      }
+    } else {
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      Object.keys(this.formMarcador.controls).forEach((key) => {
+        if (this.formMarcador.get(key).errors) {
+          this.formMarcador.get(key).markAsDirty();
+        }
+      });
+    } 
+  }
+
+  eliminarMarcador(event){
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => { 
+        this.generalService.delete(new GeneralModel('ReporteMarcadorDTO', null, false, this.reporteMarcador)).subscribe(data =>{
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR)
+          this.formMarcador.reset();
+          this.verNuevoMarcador = false;
+          this.reporteMarcador = new ReporteMarcadorModel();
+          this.cargarListaMarcadores();
+        })
+      }
+    })
+  }
+
+  eliminarCampoMarcador(event, objeto){ 
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteTablaDTO', null, false, objeto)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.cargarListaCampoMarcador();
+        })
+      }
+    })
+  }
+
+  nuevoCampoTabla(){
+    this.verReporteMarcadorDetalle = true;
+    this.bloquearCampoMarcador = true;
+    this.campoMarcadorInsertar = new ReporteTablaModel();
+    this.campoMarcadorInsertar.reporteMarcador = this.reporteMarcador.llave
+  }
+
+  validarCampoMarcador(campoMarcador){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(campoMarcador.columna)
+    validador = validador && this.utilsService.validarCampoObligatorio(campoMarcador.campoFuente)
+    return validador;
+  }
+
+  editarCampoMarcador() {
+    this.bloquearCampoMarcador = true;
+  }
+
+  agregarCampoMarcador(campoMarcador){
+    this.clickGuardarMarcadorCampo = true;
+    if (!this.validarCampoMarcador(campoMarcador)){
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    campoMarcador.reporteMarcador = this.reporteMarcador.llave;
+    if ('I' == campoMarcador.tipo){
+      if (!campoMarcador.ancho || campoMarcador.ancho == 0){
+        campoMarcador.ancho = 10;
+      }
+      if (!campoMarcador.alto || campoMarcador.alto == 0){
+        campoMarcador.alto = 10;
+      }
+    }
+    if (['G'].includes(campoMarcador.tipo)){
+      campoMarcador.columna = 0;
+    }
+    if (campoMarcador.llave){
+      this.generalService.update(new GeneralModel('ReporteTablaDTO', null, false, campoMarcador)).subscribe(data => {
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+        this.clickGuardarMarcadorCampo = false;
+        campoMarcador = new ReporteTablaModel;
+        this.bloquearCampoMarcador = false;
+        this.cargarListaCampoMarcador();
+      })
+    } else {
+      campoMarcador.llave = this.utilsService.generarLlave();
+      this.generalService.crearRegistro(new GeneralModel('ReporteTablaDTO', null, false, campoMarcador)).subscribe(data => {
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+        this.clickGuardarMarcadorCampo = false;
+        campoMarcador = new ReporteTablaModel;
+        this.verReporteMarcadorDetalle = false;
+        this.campoMarcadorInsertar = new ReporteTablaModel();
+        this.bloquearCampoMarcador = false;
+        this.cargarListaCampoMarcador();
+      })
+    }
+  }
+
+  cargarListaSoportes(){
+    this.generalService.queryForList(new GeneralModel('ReporteSoporteDTO', null, false, {reporteFuente: this.reporteFuente.llave, tipo: 'S'})).subscribe(data => {
+      this.listaSoportes = data;
+   })
+  }
+
+  async cargarListaSoportesAsync(){
+    this.listaSoportes = await this.generalService.queryForList(new GeneralModel('ReporteSoporteDTO', null, false, {reporteFuente: this.reporteFuente.llave, tipo: 'S'})).toPromise()
+  }
+
+  nuevoSoporte(){
+    this.soporteIngresar = new ReporteSoporteModel();
+    this.verSoporteArchivoDetalle = true;
+    this.habilitaCampo = true;
+  }
+
+  cancelarSoporte() {
+    this.soporteIngresar = new ReporteSoporteModel();
+    this.verSoporteArchivoDetalle = false;
+    this.habilitaCampo = false;
+  }
+
+  validarSoporte(soporte){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(soporte.descripcion)
+    validador = validador && this.utilsService.validarCampoObligatorio(soporte.archivoIndividual)
+    return validador;
+  }
+
+  agregarSoporte(soporte){
+    this.clickGuardarSoporteArchivo = true;
+    if (!this.validarSoporte(soporte)){
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      return;
+    }
+    if (!soporte.llaveTabla){
+      soporte.tipo = 'S'
+      soporte.reporteFuente = this.reporteFuente.llave
+      this.generalService.crearRegistro(new GeneralModel('ReporteSoporteDTO', null, false, soporte)).subscribe(data => {
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+        soporte = new ReporteSoporteModel;
+        this.cargarListaSoportes();
+        this.verSoporteArchivoDetalle = false;
+        this.clickGuardarSoporteArchivo = false;
+      })
+      } else {
+        this.generalService.update(new GeneralModel('ReporteSoporteDTO', null, false, soporte)).subscribe(data => {
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+          this.cargarListaSoportes();
+          this.verSoporteArchivoDetalle = false;
+          this.clickGuardarSoporteArchivo = false;
+          soporte = new ReporteSoporteModel;
+        })
+      }
+      this.habilitaCampo = false;
+  }
+
+  eliminarSoporte(event, soporte){
+    this.habilitaCampo = true;
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => { 
+        this.generalService.delete(new GeneralModel('ReporteSoporteDTO', null, false, soporte)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.cargarListaSoportes();
+          this.habilitaCampo = false;
+        })
+      }
+    })
+  }
+
+  iniciarEdicion() {
+    this.habilitaCampo = true;
+  }
+
+  async cancelarEdicion() { 
+    this.cargarListaSoportesAsync();   
+    this.habilitaCampo = false;
+    
+  }
+  
+  //Reporte Dinamico
+
+  generarJasper(){
+    this.reporteService.generarJasper(this.reporteFuente.llave, 'compensacion/ReportesBase') .subscribe({
+      next: (data) => {
+        this.notificacionesBusService.showSuccess('Se ha generado el jasper exitosamente')
+        this.validarExisteJasper();
+      }
+    });    
+  }
+
+
+  descargarJasper() {
+
+    let propiedad = 'ruta_plantillas';
+    //Ruta archivo
+    this.aplicacion = this.authService.getTokenKey('aplicacion')
+    this.cargarArchivo.descargarArchivo(this.encriptadorArchivo.encriptar('reportes/' + this.reporteFuente.llave + '.jrxml'), propiedad, this.aplicacion).subscribe({
+      next: blob => {
+      const a = document.createElement('a')
+      const objectUrl = URL.createObjectURL(blob)
+      a.href = objectUrl
+      a.download = this.reporteFuente.llave + '.jrxml' //documento.archivoorigen;
+      a.click();
+      URL.revokeObjectURL(objectUrl);
+    }
+  });
+  }
+
+  nuevoMarcadorDinamico(){
+    this.reporteMarcadorDinamico = new ReporteMarcadorModel
+    this.reporteMarcadorDinamico.origen = 'D'
+    this.reporteMarcadorDinamico.reporteFuente = this.reporteFuente.llave
+    this.reporteMarcadorDinamico.banda = this.bandaSeleccionada.key
+    this.formReporteDinamico.reset();
+    this.formReporteDinamico.patchValue(this.reporteMarcadorDinamico)
+    this.nuevoReporteMarcadorDinamico = true
+  }
+
+  verMarcadorDinamico(event){
+    this.reporteMarcadorDinamico = event.data;
+    this.formReporteDinamico.patchValue(this.reporteMarcadorDinamico)
+    this.nuevoReporteMarcadorDinamico = true;
+  }
+
+  async verBanda(event){
+    this.verTabBanda = false;
+    this.bandaSeleccionada = event.data;
+    this.reporteMarcadorDinamico = new ReporteMarcadorModel;
+    this.nuevoReporteMarcadorDinamico = false;
+    this.nuevaBanda = false;
+    if (['detalle','summary'].includes(this.bandaSeleccionada.key)){
+      await this.cargarListaMarcadorDinamico();
+    } else {
+      this.reporteBanda = await this.generalService.queryForObject(new GeneralModel('ReporteBandaDTO', null, false, {reporteFuente: this.reporteFuente.llave, banda: this.bandaSeleccionada.key})).toPromise();
+      if (!this.reporteBanda) {
+        this.nuevaBanda = true;
+        if (['detalle','summary'].includes(this.bandaSeleccionada.key)){
+          this.nuevaBanda = false;
+        }
+        this.reporteBanda = new ReporteBandaModel;
+        this.reporteBanda.totales = 'S'
+      } else {
+        await this.cargarListaMarcadorDinamico()
+      }
+    }
+    await this.sleep(25)
+    this.verTabBanda = true;
+  }
+
+  async cargarListaMarcadorDinamico(){
+    this.listaMarcadorDinamico = await this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {
+      reporteFuente: this.reporteFuente.llave, 
+      banda: this.bandaSeleccionada.key,
+      ordenDinamico: 'S',
+      origen: 'D'
+    })).toPromise();
+  }
+
+  async guardarCaracteristicaBanda(){
+    if(this.nuevaBanda) {
+      this.reporteBanda.reporteFuente = this.reporteFuente.llave;
+      this.reporteBanda.banda = this.bandaSeleccionada.key;
+      this.reporteBanda = await this.generalService.crearRegistro(new GeneralModel('ReporteBandaDTO', null, false, this.reporteBanda)).toPromise();
+    }else {
+      await this.generalService.update(new GeneralModel('ReporteBandaDTO', null, false, this.reporteBanda)).toPromise();
+    }
+    await this.sleep(25)
+    this.nuevaBanda=false;
+    this.notificacionesBusService.showInfo("Se actualizaron las caracteristicas de "+this.bandaSeleccionada.value);
+  }
+
+  async guardarColumnaDinamico(){
+    if (!this.formReporteDinamico.valid) {
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+        Object.keys(this.formReporteDinamico.controls).forEach((key) => {
+          if (this.formReporteDinamico.get(key).errors) {
+            this.formReporteDinamico.get(key).markAsDirty();
+          }
+        });
+      return;
+    }
+    this.reporteMarcadorDinamico = this.formReporteDinamico.value;
+    if(this.utilsService.isBlank(this.reporteMarcadorDinamico.llave)){
+      this.reporteMarcadorDinamico.llave = this.utilsService.generarLlave();
+      this.reporteMarcadorDinamico.origen = 'D';
+      if(this.reporteMarcadorDinamico.tipoCampo == 'C'){
+        this.reporteMarcadorDinamico.marcador = this.reporteMarcadorDinamico.filtro;
+        this.reporteMarcadorDinamico.reporteColumna = null;
+      }else{
+        var columna = new ReporteColumnaModel();
+        columna.llaveTabla = this.reporteMarcadorDinamico.marcador;
+        columna = await this.generalService.queryForObject(new GeneralModel('ReporteColumnaDTO', null, false, columna)).toPromise();
+        
+        this.reporteMarcadorDinamico.marcador = columna.nombre;
+        this.reporteMarcadorDinamico.reporteColumna = columna.llaveTabla;
+        this.reporteMarcadorDinamico.filtro = columna.sintaxis;
+        this.reporteMarcadorDinamico.tipoDato = columna.tipoDato;
+      }
+      await this.generalService.crearRegistro(new GeneralModel('ReporteMarcadorDTO', null, false, this.reporteMarcadorDinamico)).toPromise();
+    }else{
+      if(this.reporteMarcadorDinamico.tipoCampo == 'C'){
+        this.reporteMarcadorDinamico.marcador = this.reporteMarcadorDinamico.filtro;
+      }
+      await this.generalService.update(new GeneralModel('ReporteMarcadorDTO', null, false, this.reporteMarcadorDinamico)).toPromise();
+    }
+    this.reporteMarcadorDinamico = null;
+    this.nuevoReporteMarcadorDinamico = false;
+    await this.cargarListaMarcadorDinamico()
+    this.notificacionesBusService.showInfo('Se ha guardado el cambio');
+  }
+
+  regresarBandaSeleccionada(){
+    this.bandaSeleccionada = {key: null, value: null}
+  }
+
+  async eliminarColumnaDinamico(event) {
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: async () =>  {
+        await this.generalService.delete(new GeneralModel('ReporteMarcadorDTO', null, false, this.reporteMarcadorDinamico )).toPromise();
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR)
+        this.reporteMarcadorDinamico = new ReporteMarcadorModel()
+        this.nuevoReporteMarcadorDinamico = false;
+        await this.cargarListaMarcadorDinamico()
+      }
+    })
+  }
+
+  validarSeparador(){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(this.reporteFuente.separador);
+    return validador;
+  }
+
+  actualizarSeparador(){
+    this.clickGuardarReporteTexto = true;
+    if (!this.validarSeparador()){
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      return;
+    }
+    this.actualizar();
+  }
+
+  cargarListaMarcadoresTexto(){
+    this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {
+      tipoReporte: this.reporteFuentePipe.REPORTEARCHIVOPLANO,
+      reporteFuente: this.reporteFuente.llave,
+      ordenDinamico: this.generalPipe.SI
+    })).subscribe(data => {
+      this.listaMarcadoresTexto = data;
+    })
+  }
+
+  verMarcadorTexto(event){
+    this.verNuevoMarcadorTexto = true;
+    this.marcadorTexto = event.data;
+  }
+
+  nuevoMarcadorTexto(){
+    this.verNuevoMarcadorTexto = true;
+    this.marcadorTexto = new ReporteMarcadorModel();
+		this.marcadorTexto.tipoReporte = this.reporteFuentePipe.REPORTEARCHIVOPLANO;
+  }
+
+  validarMarcadorTexto() : boolean{
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorTexto.tipoGrafico);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorTexto.alto);
+    if (this.reporteFuentePipe.MARCADORTEXTOFIJO == this.marcadorTexto.tipoGrafico){
+      validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorTexto.formato);
+    }
+    if (this.reporteFuentePipe.MARCADORTEXTODINAMICO == this.marcadorTexto.tipoGrafico){
+      validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorTexto.ancho);
+      validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorTexto.reporteColumna);
+    }
+    return validador;
+  }
+
+  async guardarMarcadorTexto(){
+    this.clickGuardarMarcadorTexto = true;
+    if (!this.validarMarcadorTexto()) {
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    this.clickGuardarMarcadorTexto = false;
+    this.marcadorTexto.reporteFuente = this.reporteFuente.llave;
+    if (this.marcadorTexto.llave){
+      await this.generalService.update(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorTexto)).toPromise();
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+    } else {
+      this.marcadorTexto.llave = this.utilsService.generarLlave();
+      await this.generalService.crearRegistro(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorTexto)).toPromise();
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+    }
+    this.cargarListaMarcadoresTexto();
+    this.verNuevoMarcadorTexto = false;
+  }
+
+  eliminarMarcadoTexto(event){
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: async () =>  {
+        await this.generalService.delete(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorTexto)).toPromise();
+        this.verNuevoMarcadorTexto = false;
+        this.marcadorTexto = new ReporteMarcadorModel();
+        this.cargarListaMarcadoresTexto();
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR)
+      }
+    })
+  }
+
+  cargarListaXML(){
+    this.generalService.queryForList(new GeneralModel('ReporteMarcadorDTO', null, false, {
+      tipoReporte: 'X',
+      origen: 'X',
+      reporteFuente: this.reporteFuente.llave,
+      ordenDinamico: this.generalPipe.SI
+    })).subscribe(data => {
+      this.listaXML = data;
+    })
+  }
+
+  nuevoMarcadorXML(){
+    this.marcadorXML = new ReporteMarcadorModel();
+    this.marcadorXML.tipoReporte = 'X';
+    this.marcadorXML.origen = 'X';
+    this.verNuevoMarcadorXML = true;
+  }
+
+  verMarcadorXML(event){
+    this.marcadorXML = event.data;
+    this.verNuevoMarcadorXML = true;
+    if  (this.marcadorXML.tipo == 'MR' || this.marcadorXML.tipo == 'TB'){
+      this.cargarListaCampoMarcadorXML();
+    }
+  }
+
+  validarMarcadorXML(){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorXML.descripcion);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorXML.tipo);
+    return validador
+  }
+
+  guardarMarcadorXML(){
+    this.clickGuardarMarcadorXML = true;
+    if (!this.validarMarcadorXML()){
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    this.marcadorXML.reporteFuente = this.reporteFuente.llave;
+    if (this.marcadorXML.llave){
+      this.generalService.update(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorXML)).subscribe(data => {
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+        this.marcadorXML = new ReporteMarcadorModel();
+        this.verNuevoMarcadorXML = false;
+        this.cargarListaXML();
+      })
+    } else {
+      this.marcadorXML.llave = this.utilsService.generarLlave();
+      this.generalService.crearRegistro(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorXML)).subscribe(data => {
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+        this.marcadorXML = new ReporteMarcadorModel();
+        this.verNuevoMarcadorXML = false;
+        this.cargarListaXML();
+      })
+    }
+    this.clickGuardarMarcadorXML = false;
+  }
+
+  eliminarMarcadorXML(event){
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: async () =>  {
+        await this.generalService.delete(new GeneralModel('ReporteMarcadorDTO', null, false, this.marcadorXML)).toPromise();
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+        this.marcadorXML = new ReporteMarcadorModel();
+        this.verNuevoMarcadorXML = false;
+        this.cargarListaXML();
+      }
+    })
+  }
+
+  nuevoCampoTablaXML(){
+    this.verReporteMarcadorDetalleXML = true;
+    this.campoMarcadorInsertarXML = new ReporteTablaModel();
+    this.campoMarcadorInsertarXML.reporteMarcador = this.marcadorXML.llave
+    this.habilitaCampo = true;
+  }
+
+  cargarListaCampoMarcadorXML() {
+    this.generalService.queryForList(new GeneralModel('ReporteTablaDTO', null, false, { reporteMarcador: this.marcadorXML.llave})).subscribe(data => {
+      this.listaCamposMarcadorXML = data;
+    })
+  }
+
+  async cargarListaCampoMarcadorXMLAsync() {
+    this.habilitaCampo = false;
+    this.listaCamposMarcadorXML = await this.generalService.queryForList(new GeneralModel('ReporteTablaDTO', null, false, { reporteMarcador: this.marcadorXML.llave})).toPromise();
+  }
+
+  validarCampoMarcadorXML(campoMarcador){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(campoMarcador.campoFuente);
+    validador = validador && this.utilsService.validarCampoObligatorio(campoMarcador.marcador);
+    return validador;
+  }
+
+  agregarCampoMarcadorXML(campo: ReporteTablaModel){
+    this.clickGuardarMarcadorCampoXML = true;
+    if (!this.validarCampoMarcadorXML(campo)){
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      return;
+    }
+    if (campo.llave){
+      this.generalService.update(new GeneralModel('ReporteTablaDTO', null, false, campo)).subscribe(data => {
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+        this.campoMarcadorInsertarXML = new ReporteTablaModel();
+        this.habilitaCampo = false;
+        this.cargarListaCampoMarcadorXML();
+      })
+    } else {
+      campo.columna = 0;
+      campo.llave = this.utilsService.generarLlave();
+      this.generalService.crearRegistro(new GeneralModel('ReporteTablaDTO', null, false, campo)).subscribe(data => {
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+        campo = new ReporteTablaModel();
+        this.habilitaCampo = false;
+        this.cargarListaCampoMarcadorXML();
+      })
+    }
+    this.clickGuardarMarcadorCampoXML = false;
+    this.verReporteMarcadorDetalleXML = false;
+  }
+
+  eliminarCampoMarcadorXML(event, objeto){ 
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteTablaDTO', null, false, objeto)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.cargarListaCampoMarcadorXML();
+        })
+      }
+    })
+  }
+
+  cambiarTabColumnario(event){
+    switch (event.index) {
+      case 0:
+        this.cargarReporteColumnario();
+        break;
+      case 1:
+        this.cargarDatosAdicionales();
+        break;
+      case 2:
+        this.cargarMarcadoresColumnario();
+        break;
+    }
+  }
+
+  cargarMarcadoresColumnario() {
+    this.generalService.queryForList(new GeneralModel('ReporteColumnarioMarcadorDTO', null, false, {reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.marcadoresColumnario = data;
+    })
+  }
+
+
+  cargarDatosAdicionales() {
+    this.generalService.queryForList(new GeneralModel('ReporteColumnarioDTO', null, false, {reporteFuente: this.reporteFuente.llave, filtroColumnaBasica: 'N'})).subscribe(data => {
+      this.columnasAdicionales = data;
+    })
+  }
+
+  cargarReporteColumnario(){
+    this.generalService.queryForList(new GeneralModel('ReporteColumnarioDTO', null, false, {reporteFuente: this.reporteFuente.llave, filtroColumnaBasica: 'S'})).subscribe(data => {
+      this.listaReporteColumnario = data;
+    })
+  }
+
+  cargarGraficasColumnas() {
+    this.generalService.queryForList(new GeneralModel('ReporteColumnaDTO', null, false, {reporteFuente: this.reporteFuente.llave})).subscribe(data => {
+      this.paginadorColumnas = data;
+    })
+    this.generalService.queryForList(new GeneralModel('ReporteBandaDTO', null, false, {reporteFuente: this.reporteFuente.llave, totales: 'C'})).subscribe(data => {
+      this.paginadorColoresGrafica = data;
+    })
+  }
+
+  validarExisteJasper(){
+    this.cargarArchivo.descargarArchivo(this.encriptadorArchivo.encriptar('reportes/' + this.reporteFuente.llave + '.jrxml'), 'ruta_plantillas', this.aplicacion).subscribe(
+      (response) => {
+        this.existeJasper = true;
+      },
+      (error) => {
+        this.existeJasper = false;
+      }
+    ) 
+  }
+
+  verReporteColumnario(event){
+    this.columnaBasica = event.data;
+    this.verNuevoReporteColumnario = true;
+  }
+
+  nuevoColumnaBasica(){
+    this.columnaBasica = new ReporteColumnarioModel();
+    this.columnaBasica.reporteFuente = this.reporteFuente.llave;
+    this.verNuevoReporteColumnario = true;
+  }
+
+  validarColumnaBasica(){
+    var validador: boolean = true;
+    validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.nombre);
+    validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.tipo);
+    validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.reporteColumna);
+    if (validador){
+      if (this.isMostrarOrden()){
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.orden);
+      }
+      if (this.isMostrarOrdenConsulta()){
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.ordenConsulta);
+      }
+      if (this.reporteColumnarioPipe.TIPO_CELDA == this.columnaBasica.tipo) {
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.operacion);
+      } else if (this.reporteColumnarioPipe.TIPO_COLUMNA== this.columnaBasica.tipo) {
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.operacionHorizontal);
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.operacionVertical);
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.columnaOperacionVertical);
+      } else if (this.reporteColumnarioPipe.TIPO_LABEL == this.columnaBasica.tipo) {
+        validador =  validador && this.utilsService.validarCampoObligatorio(this.columnaBasica.orderBy);
+      }
+    }
+    return validador;
+  }
+
+  async verificarColumnasValidas(reporteColumnarioDTO): Promise<boolean> {
+    var tipo=reporteColumnarioDTO.tipo;
+		if(this.reporteColumnarioPipe.TIPO_FILA == reporteColumnarioDTO.tipo){
+			return true;
+		}
+		var filtro=new  ReporteColumnarioModel();
+		filtro.reporteFuente = reporteColumnarioDTO.reporteFuente;
+		filtro.diferenteColumnario = reporteColumnarioDTO.llaveTabla;
+		filtro.tipo = tipo;
+		var cantidad= await this.generalService.cantidadRegistros(new GeneralModel('ReporteColumnarioDTO', null, false, filtro)).toPromise();
+		if(cantidad==0){
+			return true;
+		}
+		if(this.reporteColumnarioPipe.TIPO_COLUMNA == reporteColumnarioDTO.tipo){
+				this.notificacionesBusService.showWarning("El reporte solo puede contener 1 registro con tipo "+this.reporteColumnarioPipe.TIPO_COLUMNA_DESC);
+        return false;
+		}else if(this.reporteColumnarioPipe.TIPO_CELDA == reporteColumnarioDTO.tipo){
+      this.notificacionesBusService.showWarning("El reporte solo puede contener 1 registro con tipo "+this.reporteColumnarioPipe.TIPO_CELDA_DESC);
+      return false;
+		}
+    return true;
+  }
+
+  async guardarColumnaBasica(){
+    this.clickGuardarReporteColumnario = true;
+    if (!this.validarColumnaBasica()){
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    
+    if (await this.verificarColumnasValidas(this.columnaBasica)){
+      if (this.columnaBasica.llaveTabla) {
+        await this.generalService.update(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaBasica)).toPromise();
+        this.columnaBasica = new ReporteColumnarioModel();
+        this.verNuevoReporteColumnario = false;
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+      } else {
+        await this.generalService.crearRegistro(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaBasica)).toPromise();
+        this.columnaBasica = new ReporteColumnarioModel();
+        this.verNuevoReporteColumnario = false;
+        this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+      }
+      this.clickGuardarReporteColumnario = false;
+      this.cargarReporteColumnario();
+    }
+  }
+
+  eliminarColumnaBasica(event){ 
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaBasica)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.verNuevoReporteColumnario = false;
+          this.columnaBasica = new ReporteColumnarioModel();
+          this.cargarReporteColumnario();
+        })
+        
+      }
+    })
+  }
+
+  nuevaColumnaAdicional() {
+    this.columnaAdicional = new ReporteColumnarioModel();
+    this.columnaAdicional.reporteFuente = this.reporteFuente.llave;
+    this.columnaAdicional.tipo = this.reporteColumnarioPipe.TIPO_ADICIONAL;
+    this.verNuevoColumnaAdicional = true;
+  }
+
+  verDetalleAdicional(event) {
+    this.columnaAdicional = event.data;
+    this.verNuevoColumnaAdicional = true;
+  }
+
+  validarColumnaAdicional() {
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(this.columnaAdicional.nombre);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.columnaAdicional.sintaxis);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.columnaAdicional.orden);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.columnaAdicional.orderBy);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.columnaAdicional.ordenConsulta);
+    return validador;
+  }
+
+  async guardarColumnaAdicional() {
+    this.clickGuardarColumnaAdicional = true;
+    if (!this.validarColumnaAdicional()){
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    if (this.columnaAdicional.llaveTabla) {
+      await this.generalService.update(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaAdicional)).toPromise();
+      this.columnaAdicional = new ReporteColumnarioModel();
+      this.verNuevoColumnaAdicional = false;
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+    } else {
+      await this.generalService.crearRegistro(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaAdicional)).toPromise();
+      this.columnaAdicional = new ReporteColumnarioModel();
+      this.verNuevoColumnaAdicional = false;
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+    }
+    this.clickGuardarColumnaAdicional = false;
+    this.cargarDatosAdicionales();
+  }
+
+  eliminarColumnaAdicional(event) {
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteColumnarioDTO', null, false, this.columnaAdicional)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.verNuevoColumnaAdicional = false;
+          this.columnaAdicional = new ReporteColumnarioModel();
+          this.cargarDatosAdicionales();
+        })
+      }
+    })
+  }
+
+  nuevoMarcadorColumnario() {
+    this.marcadorColumnario = new ReporteColumnarioMarcadorModel();
+    this.marcadorColumnario.reporteFuente = this.reporteFuente.llave;
+    this.verNuevoMarcadorColumnario = true;
+  }
+
+  verDetalleMarcadorColumnario(event) {
+    this.marcadorColumnario = event.data;
+    this.verNuevoMarcadorColumnario = true;
+  }
+
+  validarMarcadorColumnario() {
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorColumnario.marcador);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorColumnario.tipo);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorColumnario.textoRegistro);
+    validador = validador && this.utilsService.validarCampoObligatorio(this.marcadorColumnario.descripcion);
+    return validador;
+  }
+
+  async guardarMarcadorColumnario() {
+    this.clickGuardarMarcadorColumnario = true;
+    if (!this.validarMarcadorColumnario()){
+      this.notificacionesBusService.showError('Faltan campos obligatorios');
+      return;
+    }
+    if (this.marcadorColumnario.llaveTabla) {
+      await this.generalService.update(new GeneralModel('ReporteColumnarioMarcadorDTO', null, false, this.marcadorColumnario)).toPromise();
+      this.marcadorColumnario = new ReporteColumnarioMarcadorModel();
+      this.verNuevoMarcadorColumnario = false;
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ACTUALIZAR);
+    } else {
+      await this.generalService.crearRegistro(new GeneralModel('ReporteColumnarioMarcadorDTO', null, false, this.marcadorColumnario)).toPromise();
+      this.marcadorColumnario = new ReporteColumnarioMarcadorModel();
+      this.verNuevoMarcadorColumnario = false;
+      this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_GUARDAR);
+    }
+    this.clickGuardarMarcadorColumnario = false;
+    this.cargarMarcadoresColumnario();
+  }
+
+  eliminarMarcadorColumnario(event) {
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => {
+        this.generalService.delete(new GeneralModel('ReporteColumnarioMarcadorDTO', null, false, this.marcadorColumnario)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.verNuevoMarcadorColumnario = false;
+          this.marcadorColumnario = new ReporteColumnarioMarcadorModel();
+          this.cargarMarcadoresColumnario();
+        })
+      }
+    })
+  }
+
+  public guardarGrafico() {
+    this.actualizar();
+    this.paginadorColumnas.forEach(data => {
+      this.generalService.update(new GeneralModel('ReporteColumnaDTO', null, false, data)).subscribe(data => {})
+    });
+  }
+
+  public verGrafico() {
+    this.reporteService.verGrafico({llaveReporte: this.reporteFuente.llave}).subscribe(data => {
+      let columna = this.dashboardService.cargarGrafica({accion: data.tipoGrafico, datosGrafica: data});
+      this.grafica = columna;
+      let respuesta = this.dashboardPipe.TIPO_GRAFICO_CHART.filter(data => data.codigo == columna.datosGrafica.tipoGrafico);
+            if (respuesta.length < 0) {
+              return;
+            }
+            columna.tipoGrafico = respuesta[0].codigoChart;
+      this.tipoGrafica =  columna.tipoGrafico;
+      console.log(this.tipoGrafica)
+    })
+  }
+
+  nuevoColorCategoria(){
+    this.colorCategoria = new ReporteBandaModel();
+    this.colorCategoria.banda = '#FFFFFF';
+    this.verColorCategoriaDetalle = true;
+    this.habilitaCampo = true;
+  }
+
+  cancelarColorCategoria() {
+    this.colorCategoria = new ReporteBandaModel();
+    this.verColorCategoriaDetalle = false;
+    this.habilitaCampo = false;
+  }
+
+  validarColorCategoria(color){
+    var validador: boolean = true;
+    validador = validador && this.utilsService.validarCampoObligatorio(color.titulo)
+    validador = validador && this.utilsService.validarCampoObligatorio(color.banda)
+    return validador;
+  }
+
+  agregarColorCategoria(color){
+    this.clickGuardarColorCategoria = true;
+    if (!this.validarColorCategoria(color)){
+      this.notificacionesBusService.showError('Faltan campos obligatorios')
+      return;
+    }
+    if (!color.llaveTabla){
+      color.totales = 'C'
+      color.reporteFuente = this.reporteFuente.llave
+      this.generalService.crearRegistro(new GeneralModel('ReporteBandaDTO', null, false, color)).subscribe(data => {
+        this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_GUARDAR);
+        color = new ReporteBandaModel();
+        this.cargarGraficasColumnas();
+        this.verColorCategoriaDetalle = false;
+        this.clickGuardarColorCategoria = false;
+      })
+      } else {
+        this.generalService.update(new GeneralModel('ReporteBandaDTO', null, false, color)).subscribe(data => {
+          this.notificacionesBusService.showSuccess(this.generalPipe.MENSAJE_ACTUALIZAR);
+          this.cargarGraficasColumnas();
+          this.verColorCategoriaDetalle = false;
+          this.clickGuardarColorCategoria = false;
+          color = new ReporteBandaModel();
+        })
+      }
+      this.habilitaCampo = false;
+  }
+
+  eliminarColorCategoria(event, color){
+    this.habilitaCampo = true;
+    this.confirmationService.confirm({
+      target: event.target,
+      message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+      acceptLabel: this.generalPipe.SI_DESC,
+      header: this.translateService.instant('confirmar'),
+      accept: () => { 
+        this.generalService.delete(new GeneralModel('ReporteBandaDTO', null, false, color)).subscribe(data => {
+          this.notificacionesBusService.showInfo(this.generalPipe.MENSAJE_ELIMINAR);
+          this.cargarGraficasColumnas();
+          this.habilitaCampo = false;
+        })
+      }
+    })
+  }
+
+  async cancelarEdicionColor() { 
+    this.cargarGraficasColumnas();   
+    this.habilitaCampo = false;
+  }
+
+  public isFijo():boolean{
+    return this.filtroOrigenFuente(this.reporteFuentePipe.FIJO);
+  }
+
+  public isSql():boolean{
+    return this.filtroOrigenFuente(this.reporteFuentePipe.SQL);
+  }
+
+  /**
+	 * Permite conocer si se debe presentar en la interfaz los campos referentes a orden consulta
+	 * @return Si se debe mostrar se retornara true, de lo contrario false
+	 */
+	isMostrarOrdenConsulta(){
+		return this.reporteColumnarioPipe.TIPO_FILA == this.columnaBasica.tipo;
+	}
+	
+
+	isMostrarOrden(){
+		return this.reporteColumnarioPipe.TIPO_FILA == this.columnaBasica.tipo||
+				this.reporteColumnarioPipe.TIPO_COLUMNA == this.columnaBasica.tipo||this.reporteColumnarioPipe.TIPO_LABEL == this.columnaBasica.tipo;
+	}
+
+	isTipoColumna(){
+		return this.reporteColumnarioPipe.TIPO_COLUMNA == this.columnaBasica.tipo;
+	}
+	
+
+	isTipoFila(){
+		return this.reporteColumnarioPipe.TIPO_FILA == this.columnaBasica.tipo;	
+	}
+
+	isTipoLabel(){
+		return this.reporteColumnarioPipe.TIPO_LABEL == this.columnaBasica.tipo;	
+	}
+
+  sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  public isFuente():boolean{
+    return this.filtroOrigenFuente(this.reporteFuentePipe.FUENTE);
+  }
+
+  public filtroOrigenFuente(tipo:string):boolean{
+    return this.reporteFuente.origenFuente == tipo;
+  }
+}