general-library-union 3.2.96 → 3.2.97

package/src/app/webcommon/pages/fuente-reporte/fuente-reporte.component.ts

@@ -0,0 +1,763 @@
+import { PopupEditorFormulaComponent } from './../../popups/popup-editor-formula/popup-editor-formula.component';
+import { GeneralPipe } from './../../pipes/general.pipe';
+import { ToastService } from './../../../core/servicios/toast.service';
+import { Component, OnInit, ViewChild } from '@angular/core';
+import { ColumnaFuenteModel } from '../../../seguridad/modelos/ColumnaFuenteModel';
+import { FuenteDatoModel } from '../../../seguridad/modelos/FuenteDato';
+import { ReporteColumnaModel } from '../../../seguridad/modelos/ReporteColumna';
+import { TablaFromModel } from '../../../seguridad/modelos/TablaFromModel';
+import { JoinFromModel } from '../../../seguridad/modelos/JoinFromModel';
+import { ReportesService } from '../../services/reportes.service';
+import { LlaveForaneaModel } from '../../../seguridad/modelos/LlaveForaneaModel';
+import { ForeingWraperModel } from '../../../seguridad/modelos/ForeingWraperModel';
+import { GeneralService } from '../../../shared/servicios/general.service';
+import { GeneralModel } from '../../../seguridad/modelos/GeneralModel';
+import { ColumnaWraperModel } from '../../../seguridad/modelos/ColumnaWraperModel';
+import { UtilsService } from '../../../core/servicios/utils.service';
+import { ConfirmationService, MenuItem, MessageService } from 'primeng/api';
+import { TranslateModule, TranslateService } from '@ngx-translate/core';
+import { ConstantesGenerales } from '../../../seguridad/constantes/ConstantesGenerales';
+import { ButtonModule } from 'primeng/button';
+import { ConfirmPopupModule } from 'primeng/confirmpopup';
+import { InputTextareaModule } from 'primeng/inputtextarea';
+import { InputTextModule } from 'primeng/inputtext';
+import { CommonModule, NgIf } from '@angular/common';
+import { AccordionModule } from 'primeng/accordion';
+import { DropdownModule } from 'primeng/dropdown';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TableModule } from 'primeng/table';
+import { TablaGeneralComponent } from '../../../core/componentes/tabla-general/tabla-general.component';
+import { FiltroGeneralComponent } from '../../../core/componentes/filtro-general/filtro-general.component';
+import { MenuService } from '../../../core/servicios/menu.service';
+import { SplitButtonModule } from 'primeng/splitbutton';
+import { TabViewModule } from 'primeng/tabview';
+import { StepsModule } from 'primeng/steps';
+import { PopupTablasFuenteComponent } from '../../popups/popup-tablas-fuente/popup-tablas-fuente.component';
+import { CheckboxModule } from 'primeng/checkbox';
+import { TooltipModule } from 'primeng/tooltip';
+import { ReporteEntradaConstantes } from '../../../seguridad/constantes/ReporteEntradaConstantes';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+
+
+
+@Component({
+	selector: 'app-fuente-reporte',
+	standalone: true,
+	imports: [ProgressBarModule,TooltipModule,CheckboxModule,PopupTablasFuenteComponent,StepsModule,CommonModule,TabViewModule,SplitButtonModule,NgIf,
+		TranslateModule, InputTextModule,CommonModule, AccordionModule, DropdownModule, FormsModule, TableModule, TablaGeneralComponent, FiltroGeneralComponent, 
+		ButtonModule, ReactiveFormsModule, GeneralPipe, InputTextareaModule, ConfirmPopupModule, ButtonModule,ConfirmDialogModule,PopupEditorFormulaComponent],
+	providers: [MessageService,ConfirmationService],
+	templateUrl: './fuente-reporte.component.html',
+	styleUrl: './fuente-reporte.component.scss'
+})
+export class FuenteReporteComponent implements OnInit {
+
+	public fuente: FuenteDatoModel = new FuenteDatoModel();
+	public vistaVisualizar: string
+	public tablasFrom: TablaFromModel[] = []; // from TablaFrom
+	public joinsFrom: JoinFromModel[] = [];   //from JoinFrom 
+	public columnas: ReporteColumnaModel[] = [];
+	public listaColumnas: any[] = [];
+	public listaJoin: any[] = [];
+	public col1: string;
+	public col2: string;
+	public campos: ColumnaFuenteModel[] = [];
+	public camposSeleccionar: ColumnaWraperModel[] = [];
+	public mostrarSeleccionar: boolean;
+	public campoFormula: ColumnaFuenteModel = new ColumnaFuenteModel();
+	public actual: number;
+	public tabPrincipal: number;
+	public basico: boolean;
+	public seleccionGeneral: boolean;
+	public foraneas: any[] = [];
+	public descripcion: string;
+	public query: string;
+	public paginador: FuenteDatoModel[] = [];
+	public filtro: FuenteDatoModel = new FuenteDatoModel();
+	public paginator = {
+		rows: 10,
+		totalRecords: 0,
+	};
+	public columns : any[] = [];
+  	public filters : any[] = [];
+	public loading : boolean;
+	public menu: MenuItem[] = [];
+	public items: MenuItem[] = [];
+	public mapaMensajes: Map<number,string> = new Map<number,string>();
+	@ViewChild('popupTablasFuenteUI') popupTablasFuenteUI: PopupTablasFuenteComponent;
+	@ViewChild('popupEditorFormula') popupEditorFormula: PopupEditorFormulaComponent;
+	public tiposDato =  ReporteEntradaConstantes.tipoDato
+	public clickGuardar: boolean;
+	public verNuevoJoin: boolean;
+	public activeIndex: number = 0;
+	public cargarPaso: boolean;
+	loadingGenerar: boolean;
+	errorQuery: boolean;
+	tipoDatos: Map<string, string> = new Map<string, string>();
+
+	constructor(private menuService: MenuService,private notificationBusService: ToastService, private reportesSvc: ReportesService, private generalSvc: GeneralService, public utilsService: UtilsService, private confirmationService: ConfirmationService, private translateService: TranslateService,
+		public messageService: MessageService, private generalPipe: GeneralPipe) { }
+
+	ngOnInit(): void {
+		this.tipoDatos =  ReporteEntradaConstantes.tipoDato;
+		console.log(this.tipoDatos.get('F'));
+		this.listaColumnas = [];
+		this.campos = [];
+		this.listaJoin = [];
+		this.columnas = [];
+		this.tablasFrom = [];
+		this.camposSeleccionar = [];
+		this.joinsFrom = [];
+		this.actual = 0;
+		this.menuService.setBreadcrumb([{ label: 'Fuente Reporte' }]);
+		this.columns = [
+		  {
+			field:  'descripcion',
+			header: this.translateService.instant('descripcion'),
+			width: 100,
+		  },
+		];
+		this.filters = [
+		  {
+			field: 'descripcion',
+			header: this.translateService.instant('descripcion'),
+			matchMode: 'contains',
+		  }
+		];
+		this.initStep();
+	}
+
+	public async load(event) {
+		try {
+			this.loading =true;
+			this.filtro.paginacionRegistroInicial = event?.first != null ? event?.first : 0;
+			this.filtro.paginacionRegistroFinal = event?.rows != null ? event?.rows : 10;
+			this.filtro.origen = ("F");
+			this.filtro.descripcion = event?.filters.descripcion?.value ?  ConstantesGenerales.PORCENTAJE + event?.filters.descripcion?.value + ConstantesGenerales.PORCENTAJE : null
+			this.paginador = await this.reportesSvc.consultarFuenteDato(this.filtro).toPromise();
+			this.paginator.totalRecords = await this.reportesSvc.cantidadFuenteDato(this.filtro).toPromise();
+		} catch (e) {
+			console.error(e);
+		}
+		this.loading =false;
+	}
+
+
+	public limpiarCampos() {
+		this.descripcion = null;
+	}
+
+	public async siguiente() {
+		try {
+			if (this.validarWizard()) {
+				this.cargarPaso = true;
+				if (this.actual < 3) {
+					if (this.actual == 0) {
+						this.foraneas = [];
+						if (this.tablasFrom.length == 0) { // No selecciono ninguna tabla
+							this.notificationBusService.showInfo("Debe seleccionar al menos un objeto.");
+							this.cargarPaso = false;
+							return;
+						} else if (this.tablasFrom.length == 1) { // Solo selecciono una, por eso no hay que generar joins.
+							this.actual++;
+						} else {
+							let nombresTablas = [];
+							for (let tabla of this.tablasFrom) {
+								if (!nombresTablas.includes(tabla.tabla)) {
+									nombresTablas.push(tabla.tabla);
+								}
+							}
+							this.foraneas = [];
+							//List<LlaveForanea> 
+							let llaves: LlaveForaneaModel[] = await this.reportesSvc.getLlaves(nombresTablas).toPromise();
+							for (let i = 0; i < this.tablasFrom.length; i++) {
+								for (let j = 0; j < this.tablasFrom.length; j++) {
+									for (let foranea of llaves) {
+										if (foranea.tabla1 == (this.tablasFrom[i].tabla) && foranea.tabla2 == (this.tablasFrom[j].tabla)) {
+											let nuevo: ForeingWraperModel = new ForeingWraperModel();
+											nuevo.alias1 = (this.tablasFrom[i].alias);
+											nuevo.alias2 = (this.tablasFrom[j].alias);
+											nuevo.llave = (foranea);
+											this.foraneas.push(nuevo);
+										}
+									}
+								}
+							}
+
+						}
+
+						// Cargo las columnas para los siguientes procesos.
+
+						this.columnas = [];
+						this.listaColumnas = [];
+						this.camposSeleccionar = [];
+
+						for (let from of this.tablasFrom) {
+							//ReporteColumnaDTO 
+							let ta = new ReporteColumnaModel();
+							ta.reporteFuente = (from.tabla);
+							//List<ReporteColumnaDTO> 
+							let nuevas: ReporteColumnaModel[] = await this.generalSvc.queryForList(new GeneralModel('ReporteColumnaDTO', 'Reportes.consultarColumnas', false, ta)).toPromise();
+							this.cargarListasColumnas(nuevas, from.alias);
+						}
+
+					}
+					this.actual++;
+				} else {
+					this.terminarPasos();
+				}
+				this.cargarPaso = false;
+			}
+		} catch (e) {
+			console.error(e);
+			this.cargarPaso = false;
+		}
+	}
+
+	private async cargarListasColumnas(nuevas: ReporteColumnaModel[], alias: string) {
+		for (let col of nuevas) {
+			col.reporteFuente = (alias);
+			this.columnas.push(col);
+			this.listaColumnas.push({ value: col.reporteFuente + '.' + col.nombre, label: col.reporteFuente + '.' + col.nombre });
+			let campo = new ColumnaWraperModel();
+			campo.columna = col;
+			campo.alias = col.nombre;
+			this.camposSeleccionar.push(campo);
+		}
+	}
+
+	public async terminarPasos() {
+		this.loadingGenerar = true;
+		let camposSql = "";
+		let i = 0;
+		for (let col of this.camposSeleccionar) {
+			if (col.seleccionado) {
+				camposSql += (i == 0 ? "" : ",") + col.columna.nombre + " as " + col.alias;
+				i++;
+			}
+		}
+
+		this.fuente.whereJoin = (this.generarSqlJoin());
+		this.fuente.fromSql = (this.generarSqlFrom());
+		let where = "";
+		let estaBlancoWhereJoin: boolean = this.fuente.whereJoin == null || "" == (this.fuente.whereJoin);
+		let estaBlancoWhereAdicional: boolean = this.fuente.whereAdicional == null || "" == (this.fuente.whereAdicional);
+		if (!estaBlancoWhereJoin || !estaBlancoWhereAdicional) {
+			where = " \nWHERE ";
+			if (!estaBlancoWhereJoin && !estaBlancoWhereAdicional) {
+				where += this.fuente.whereJoin + " AND \n(" + this.fuente.whereAdicional + ")";
+			} else if (!estaBlancoWhereJoin) {
+				where += this.fuente.whereJoin;
+			} else {
+				where += this.fuente.whereAdicional;
+			}
+		}
+		try {
+			let sql = "SELECT \n" + camposSql + " \nFROM \n" + this.fuente.fromSql + where;
+			await this.reportesSvc.validarQuery(sql).toPromise();
+			this.fuente.query = (sql);
+			this.query = sql;
+			this.tabPrincipal = 0;
+			this.tablasFrom = [];
+			this.construirColumnas();
+			this.actual = 0;
+			this.notificationBusService.showInfo('Query creada satisfactoriamente.');
+			this.loadingGenerar = false;
+		} catch (e) {
+			console.error(e);
+			this.loadingGenerar = false;
+		}
+	}
+
+	public async adicionarForanea(evento) {
+		try {
+			//ForeingWraper 
+			let foranea: ForeingWraperModel = evento.data;
+			for (let rel of foranea.llave.relaciones) {
+				let par = rel.split(":");
+				let join = new JoinFromModel();
+				join.columna1 = (foranea.alias1 + "." + par[0]);
+				join.columna2 = (foranea.alias2 + "." + par[1]);
+				if(this.joinsFrom.some(data => data.columna1 === join.columna1 && data.columna2 === join.columna2)){
+					this.notificationBusService.showWarning('Registro ya se encuentra asociado.')
+				}else{
+					this.joinsFrom.push(join);
+				}
+				
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public async eliminar() {
+		this.confirmationService.confirm({
+			target: event.target,
+			key: 'eliminar',
+			message:  this.generalPipe.MENSAJE_ELIMINAR_CONFIRMAR,
+			acceptLabel: this.generalPipe.SI_DESC,
+			header: this.translateService.instant('confirmar'),
+			accept: () => {
+				this.setRespuesta(true)
+			},
+			reject: () => {
+
+			}
+		});
+	}
+
+	public async setRespuesta(respuesta: boolean) {
+		try {
+			if (respuesta) {
+				this.reportesSvc.eliminarFuenteDatosConHijos(this.fuente).toPromise();
+				this.regresar();
+				this.notificationBusService.showInfo("La fuente ha sido eliminada.");
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public anterior() {
+		if (this.actual > 0){
+		if(this.actual == 2 && this.tablasFrom.length == 1){
+			this.actual = 0;
+		}else{
+			this.actual--;
+		}
+		}
+			
+	}
+
+	public async validarQuery() {
+		try {
+			if (this.utilsService.validarTextoSQL(this.query, true, true, 8000, true) == null) {
+				this.reportesSvc.validarQuery(this.query);
+				this.errorQuery = false;
+				this.notificationBusService.showInfo("El query esta correcto.");
+			}else{
+				this.errorQuery = true;
+				this.notificationBusService.showError(this.utilsService.validarTextoSQL(this.query, true, true, 8000, true));
+			}
+		} catch (e) {
+			this.errorQuery = true;
+			this.notificationBusService.showError(e)
+		}
+	}
+
+	public adicionarJoin() {
+		try {
+			if (this.col1 != null && this.col2 != null) {
+				// TODO: Falta validar el tipo
+				let nuevo = new JoinFromModel();
+				nuevo.columna1 = (this.col1);
+				nuevo.columna2 = (this.col2);
+				this.joinsFrom.push(nuevo);
+				this.cancelarNuevoJoin();
+			} else {
+				this.notificationBusService.showWarning("Debe seleccionar dos campos");
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	nuevoJoin(){
+		this.verNuevoJoin = true;
+		this.col1 =  '';
+		this.col2 = '';
+	}
+
+	cancelarNuevoJoin(){
+		this.verNuevoJoin = false;
+		this.col1 =  '';
+		this.col2 = '';
+	}
+
+	public eliminarJoin(ae) {
+		try {
+			//let  join = (JoinFrom) ((UIParameter) ae.getComponent().findComponent("join")).getValue();
+			this.joinsFrom =  this.joinsFrom.filter((data) => data.columna1 !== ae?.columna1);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public eliminarTabla(ae) {
+		try {
+			//TablaFrom tabla = (TablaFrom) ((UIParameter) ae.getComponent().findComponent("tabla")).getValue();
+			this.tablasFrom = this.tablasFrom.filter((data) => data != ae);
+			this.notificationBusService.showWarning(this.generalPipe.MENSAJE_ELIMINAR);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public buscarTabla() {
+		this.popupTablasFuenteUI.buscarTabla("fuenteUI.tablaSeleccionada");
+	}
+
+	public setTablaSeleccionada(tablaSeleccionada: any[]) {
+		try {
+			let tablas = [];
+			for (let tabla of this.tablasFrom) {
+				if (!tablas.includes(tabla.tabla)) {
+					tablas.push(tabla.tabla);
+				}
+			}
+			tablaSeleccionada.forEach(element => {
+				this.cargarTablaEnLista(element.objeto);
+			});
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	private cargarTablaEnLista(tabla: string) {
+		let par = tabla.split("_");
+		let alias = par[0];
+		let i = 1;
+		let tablaTemp = new TablaFromModel()
+		tablaTemp.alias = alias;
+		while (this.tablasFrom.includes(tablaTemp)) {
+			alias = tabla + (i++);
+		}
+		let tem = new TablaFromModel();
+		tem.tabla = tabla;
+		tem.alias = alias;
+		this.tablasFrom.push(tem);
+		return alias;
+	}
+
+
+
+	public cambioJoin(ce) {
+		try {
+			this.listaJoin = [];
+			let nuevo = ce.value;
+			if (nuevo != null) {
+				//ReporteColumnaDTO 
+				let act: ReporteColumnaModel = null;
+				for (let col of this.columnas) {
+					if (nuevo ==(col.reporteFuente + "." + col.nombre)) {
+						act = col;
+						break;
+					}
+				}
+				for (let col of this.columnas) {
+					if (!col.reporteFuente.startsWith(act.reporteFuente) && col.tipoDato == (act.tipoDato) && col.orden == (act.orden)) {
+						let val = col.reporteFuente + "." + col.nombre;
+						this.listaJoin.push({ value: val, label: val });
+					}
+				}
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public editarCampo(evento) {
+		try {
+			let col: ColumnaFuenteModel = evento.data;
+			this.campoFormula = col;
+			let vars = [];
+			for (let campo of this.campos) {
+				let var1: any;
+				var1.nombre = (campo.nombre);
+				var1.tipo = (campo.tipoDato);
+				vars.push(var1);
+			}
+			//getBean(EditorFormulaUI.class).editar(col.getSintaxis(), "fuenteUI.formula", vars);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public editarWhere() {
+		try {
+			let vars = [];
+			for (let col of this.columnas) {
+				vars.push({nombre: col.reporteFuente + "." + col.nombre, tipo: col.tipoDato});
+			}
+			this.popupEditorFormula.editar(this.fuente.whereAdicional,'fuenteUI.fuente.whereAdicional',vars);
+			//getBean(EditorFormulaUI.class).editar(fuente.getWhereAdicional(), "fuenteUI.fuente.whereAdicional", vars);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public setFormula(formula) {
+		if (this.campoFormula != null) {
+			this.campoFormula.sintaxis = (formula);
+		}
+		this.campoFormula = null;
+	}
+
+	public adicionarColumnas() {
+		for (let col of this.camposSeleccionar) {
+			col.seleccionado = (false);
+		}
+		this.mostrarSeleccionar = true;
+	}
+
+	public agregarSeleccionados() {
+		try {
+			for (let col of this.camposSeleccionar) {
+				if (col.seleccionado) {
+					//ColumnaFuenteDTO 
+					let campo = new ColumnaFuenteModel();
+					campo.fuenteDato = (this.fuente.llave);
+					campo.nombre = (col.columna.nombre);
+					campo.sintaxis = (col.columna.nombre);
+					this.campos.push(campo);
+				}
+			}
+			this.ocultarSeleccionar();
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public ocultarSeleccionar() {
+		this.mostrarSeleccionar = false;
+	}
+
+	public async verDetalle(evento) {
+		try {
+			this.vistaVisualizar = 'mantenimiento';
+			let fuenteDatoDTO = evento;
+			this.fuente = new FuenteDatoModel();
+			this.fuente.llave = (fuenteDatoDTO.llave);
+			this.fuente = await this.reportesSvc.consultarUnicaFuenteDato(this.fuente).toPromise();
+			if (this.fuente.query2 != null) {
+				this.query = this.fuente.query + this.fuente.query2;
+			} else {
+				this.query = this.fuente.query;
+			}
+			//ColumnaFuenteDTO 
+			let col = new ColumnaFuenteModel();
+			col.fuenteDato = (this.fuente.llave);
+			this.campos = await this.reportesSvc.consultarColumnasFuente(col).toPromise();
+			this.actual = 0;
+			this.menuService.setBreadcrumb([{ label: 'Fuente Reporte', command: (event) => this.regresar() }, {label: 'Mantenimiento Fuente', }]);
+			this.cargasOpciones();
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	public nuevo() {
+		try {
+			this.vistaVisualizar = 'mantenimiento';
+			this.fuente = new FuenteDatoModel();
+			this.fuente.origen = ("F");
+			this.campos = [];
+			this.query = null;
+			this.tabPrincipal = 0;
+			this.actual = 0;
+			this.menuService.setBreadcrumb([{ label: 'Fuente Reporte', command: (event) => this.regresar() }, {label: 'Mantenimiento Fuente', }]);
+			this.cargasOpciones();
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	cargasOpciones(){
+		this.menu= [{label: this.translateService.instant('link_eliminar'), icon: 'glyphicons glyphicons-bin', visible: this.fuente.llave != null, command: (event) => {this.eliminar()}},
+		{label: this.translateService.instant('link_validar'), icon: 'glyphicons glyphicons-check', command: (event) => {this.validarQuery()}},
+		{label: this.translateService.instant('link_generar'), icon: 'glyphicons glyphicons-refresh',visible: this.fuente.llave != null, command: (event) => {this.construirColumnas()}},
+		]
+	}
+
+	regresar(){
+		console.log('hola');
+		
+		this.vistaVisualizar = null;
+		this.ngOnInit();
+	}
+
+	private validar(): boolean {
+		let res = true;
+		this.clickGuardar = true;
+		res = res && this.utilsService.validarCampoObligatorio(this.fuente.descripcion);
+		res = res && (this.utilsService.validarTextoSQL(this.query, true, true, 8000, true) == null);
+		return res;
+	}
+
+	/**
+	 * Registra/actualiza la informacion general de la fuente de datos
+	 */
+	public async guardar() {
+		try {
+			if (this.validar()) {
+				this.clickGuardar = false;
+				if (this.query.length > 4000) {
+					this.fuente.query = (this.query.substring(0, 3999));
+					this.fuente.query2 = (this.query.substring(3999, this.query.length));
+				} else {
+					this.fuente.query = (this.query);
+					this.fuente.query2 = (null);
+				}
+
+				if (this.fuente.llave == null) {
+					this.fuente.llave = (this.utilsService.generarLlave());
+					await this.reportesSvc.insertarFuenteDato(this.fuente).toPromise();
+					this.cargasOpciones();
+					
+				} else {
+					await this.reportesSvc.actualizarFuenteDato(this.fuente).toPromise();
+				}
+				this.notificationBusService.showInfo("Los cambios han sido guardados");
+			}else{
+				this.notificationBusService.showError(this.generalPipe.MENSAJE_CAMPOS_OBLIGATORIOS);
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}//guardar
+
+	/**
+	 * Registra/actualiza las columnas generados para la fuente de datos como registros de tipo 'ColumnaFuente'
+	 */
+	public async guardarCampos() {
+		try {
+			if (this.fuente.llave == null) {
+				this.notificationBusService.showInfo("Por favor diligencie primero los datos de la fuente");
+				return;
+			}
+			if (this.validarCampos()) {
+				await this.reportesSvc.actualizarColumnasFuente(this.fuente, this.campos).toPromise();
+				this.notificationBusService.showInfo("Se han guardado los campos");
+			}
+		} catch (e) {
+			console.error(e);
+		}
+	}//guardarCampos
+
+	/**
+	 * Verifica que los valores asociados a los campos para la creacion de las columnas de la fuente sean válidos
+	 * @return false en caso de que los valores asignados a los campos sean nulos o no sean palabras válidas de acuerdo 
+	 * con las condiciones dadas por ValidadorUtil.validarPalabra()),
+	 * en caso contrario retorna true
+	 */
+	private validarCampos() {
+		for (let col of this.campos) {
+			if (col.nombre == null || !this.utilsService.validarPalabra(col.nombre)) {
+				this.notificationBusService.showInfo("Nombre no valido (" + col.nombre + ")");
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Construye las columnas de la fuente de datos, con base en los campos obtenidos 
+	 * de la consulta SQL asociada
+	 */
+	public async construirColumnas() {
+		try {
+			this.campos = await this.reportesSvc.getColumnasSql(this.query).toPromise();
+			this.notificationBusService.showSuccess('Tabla generada satisfactoriamente.');
+		} catch (e) {
+			console.error(e);
+		}
+	}//construirColumnas
+
+
+
+	private validarWizard() {
+		let alias: string[] = [];
+		for (let tabla of this.tablasFrom) {
+			if (alias.includes(tabla.alias)) {
+				this.notificationBusService.showInfo("No se puede repetir el alias de las tablas.");
+				return false;
+			} else {
+				alias.push(tabla.alias);
+			}
+		}
+		alias = [];
+		for (let col of this.camposSeleccionar) {
+			if (col.seleccionado) {
+				if (alias.includes(col.alias)) {
+					this.notificationBusService.showInfo("No se puede repetir el alias de las columnas.");
+					return false;
+				} else {
+					alias.push(col.alias);
+				}
+			}
+		}
+
+		return true;
+	}
+
+	private generarSqlFrom() {
+		let res = "";
+		let i = 0;
+		for (let tabla of this.tablasFrom) {
+			res += (i == 0 ? "" : ",") + tabla.tabla + " " + tabla.alias;
+			i++;
+		}
+		return res;
+	}
+
+	private generarSqlJoin() {
+		let res = "";
+		let i = 0;
+		for (let join of this.joinsFrom) {
+			res += (i == 0 ? "" : " AND ") + join.columna1 + " = " + join.columna2;
+			i++;
+		}
+		return res;
+	}
+
+	//IMPLEMENTACION STEPER
+	initStep(){
+		this.mapaMensajes.set(0,'Seleccione las tablas o vistas de donde desea obtener la informaci'+this.generalPipe.O_TIDLE_MIN+'n.')
+		this.mapaMensajes.set(1,'Indique de qu'+this.generalPipe.E_TILDE_MIN+' manera se relacionan los objetos entre s'+this.generalPipe.I_TILDE_MIN+'.')
+		this.mapaMensajes.set(2,'Indique los filtros adicionales que desee realizar sobre la informaci'+this.generalPipe.O_TIDLE_MIN+'n.')
+		this.mapaMensajes.set(3,'Seleccione los campos que desee ver en la consulta.')
+		this.items = [
+            {
+                label: this.translateService.instant('from'),
+                command: (event) => {console.log(event);},
+				disabled: true,
+				title:'Seleccione las tablas o vistas de donde desea obtener la informacion.'
+            },
+            {
+                label: this.translateService.instant('join'),
+				command: (event) => {console.log(event);},
+				disabled: true,
+                title: 'Indique de que manera se relaccionan los objetos entre si.'
+            },
+            {
+                label: this.translateService.instant('where'),
+				command: (event) => {console.log(event);},
+				disabled: true,
+                title: 'Indique los filtros adicionales que desee realizar sobre la informacion.'
+            },
+            {
+                label: this.translateService.instant('campos'),
+                command: (event) => {console.log(event);},
+				disabled: true,
+            }
+        ];
+	}
+
+	actualizarSeleccion(booleanogeneral: boolean): void {
+		this.camposSeleccionar.forEach((elemento) => {
+			elemento.seleccionado = booleanogeneral;
+		});
+	}
+
+	todosSeleccionados(): boolean {
+		return this.camposSeleccionar.every(elemento => elemento.seleccionado);
+	}
+	
+	isQueryValido(): boolean{
+		return this.utilsService.validarTextoSQL(this.query, true, true, 8000, true) == null;
+	}
+
+
+}