package es.ejie.frmk.listeners.validadorremoto;

import java.io.IOException;
import java.util.Collection;
import java.util.Locale;
import java.util.Vector;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.beanutils.DynaBean;

import weblogic.xml.stream.ElementFactory;
import weblogic.xml.stream.XMLOutputStream;
import weblogic.xml.stream.XMLOutputStreamFactory;

import es.ejie.frmk.control.excepciones.Q70GestorDeExcepciones;
import es.ejie.frmk.infraestructura.logs.navegacion.Q70LogNavegacion;
import es.ejie.frmk.infraestructura.tablas.Q70GestorTablasCodigos;
import es.ejie.frmk.infraestructura.tablas.Q70GestorTablasException;
import es.ejie.frmk.infraestructura.traza.Q70TraceLevel;
import es.ejie.frmk.infraestructura.traza.Q70Traza;
import es.ejie.frmk.listeners.base.Q70HTTPListener;
import es.ejie.frmk.listeners.base.Q70LogDataUtils;
import es.ejie.frmk.presentacion.iu.taglib.base.Q70Constants;

/**
 * Esta clase implementa la parte servidora del Gestor de Validaciones Remotas
 * <p> 
 * Es el punto de entrada para realizar la validación on-Line de ciertos campos de entrada
 * de algunos formularios “críticos” antes de submitirse el formulario.
 * El Gestor de Validaciones Remotas Listener extiende de HttpServlet, de tal modo que es 
 * capaz de escuchar peticiones de protocolo http. <code>Q70HttpListener</code> es un interfaz que 
 * debe ser implementado por todos los componentes que extiendan de <code>Servlet<code> en Geremua y 
 * que sigan el protocolo http. Por lo tanto, <code>Q70ValidadorRemotoListener</code> implementará también
 * esta interfaz.
 * <p>
 * La clase colaborará con otros componentes de Geremua:
 * <ul>
 * <li>El Gestor de Excepciones</li> 
 * <li>El Gestor de Tablas de Códigos</li>
 * </ul>
 * para validar los datos de entrada. 
 * Seguidamente decidirá sobre qué campos del formulario de entrada 
 * se devolverán los valores validados.
 * Creará un flujo de salida hacia el browser que realizó la petición 
 * y escribirá el HTML generado sobre el flujo de salida.
 */

public class Q70ValidadorRemotoListener
	extends HttpServlet
	implements Q70HTTPListener {

//	-------------------------------------------------------------- Vbles.
	
		/**
		 * Constante que indica el componente al que pertenece la clase. Es
		 * necesario para el uso del log de trazas.
		 */
		private static final String COMPONENTE = "VALIDADOR_REMOTO";
		/**
		 * Constante que indica el canal.
		 */
		private static final String CANAL = "BROWSER-PC AUXILIAR";
		
		/**
		 * Instancia del log de trazas
		 */
		private static Q70Traza tr = null;

		/**
		 * Instancia del log de navegación
		 */
		private static Q70LogNavegacion logNav = null;


//	-------------------------------------------------------------- Metodos publicos
		
	/**
	 * Método de entrada de la petición de validación remota.
	 * <p>
	 * Escribe la entrada en el log de navegación,
	 * delega el procesamiento de la petición en el método <code>listener</code>
	 * y escribe la salida en el log de navegación.
	 * 
	 * @param <code>req</code> Petición a procesar
	 * @param <code>resp</code> Respuesta a crear
	 * @exception <code>ServletException</code>
	 * @exception <code>IOException</code>
	 */
	public void service(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException 
	{
		
		try {

			if (null == tr)	
				tr = Q70Traza.getSingleton();		
			if (null == logNav)	
				logNav = Q70LogNavegacion.getSingleton();
			
			Q70LogDataUtils.processPrepareLogData(req,CANAL,COMPONENTE);
			writeNavLogBegin();
			this.listen(req, resp);
			writeNavLogEnd();
			
		}
		catch (ServletException se) 
		{
			if (tr.isTraceActive())
			{
				tr.trace(COMPONENTE, Q70TraceLevel.ERROR, "ServletException.");
			}
			catchGenericThrowables(se,req,resp);
		} 
		catch (IOException ioe) 
		{
			if (tr.isTraceActive())
			{
				tr.trace(COMPONENTE, Q70TraceLevel.ERROR, "IOException.");
			}
			catchGenericThrowables(ioe,req,resp);
		} 
		catch (Throwable te) 
		{
			if (tr.isTraceActive())
			{
				tr.trace(COMPONENTE, Q70TraceLevel.ERROR, "Throwable recogida por el Q70ListasEnlazadasListener.");
			}
			catchGenericThrowables(te,req,resp);
		}
		
		//Borrar la informacion de logs generada
		Q70LogDataUtils.clearLogData(COMPONENTE);
	}

	/**
	 * Método del interfaz HTTPListener que delega su funcionalidad en el método <code>process</code>.
	 * <p>
	 * @param <code>req</code> Petición a procesar
	 * @param <code>resp</code> Respuesta a crear
	 * @exception <code>ServletException</code>
	 * @exception <code>IOException</code>
	 * @exception <code>Q70ValidadorRemotoException</code>
	 */
	public void listen(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException, Q70ValidadorRemotoException 
	{
			process(req, resp);
	}

	/**
	 * Método que trata todo <b>throwable</b> no capturado por capas posteriores.
	 * <p>
	 * Colabora con el <b>Gestor de Excepciones</b>, enviándole el throwable recogido, para que éste lo trate 
	 * y lo registre en el Log de Incidencias
	 * 
	 * @param <code>t</code> Throwable a tratar.
	 * @param <code>request</code> Petición a procesar
	 * @param <code>response</code> Respuesta a crear
	 */
	public void catchGenericThrowables(Throwable t,HttpServletRequest req, HttpServletResponse res) 
	{
		Q70GestorDeExcepciones.getSingleton().recogerThrowable(t, req, res);
	}

	/**
	 * Método que registra un inicio de navegación en el log de navegación.
	 *  
	 * 
	 */
	public void writeNavLogBegin() 
	{
		logNav.log(Q70LogNavegacion.RESPUESTA_OK, Q70LogNavegacion.TIPO_NAVEGACION_ENTRADA);
	}

	/**
	 * Método que registra un fin de navegación en el log de navegación.
	 * 
	 * 
	 */
	public void writeNavLogEnd() 
	{
		logNav.log(Q70LogNavegacion.RESPUESTA_OK, Q70LogNavegacion.TIPO_NAVEGACION_SALIDA);
	}
	
	public void dispatch(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {}
	
	
	
//----------------------------------------------------------------  Metodos privados
	/**
	 * Este método procesa la petición, obtiene los valores validados y actualiza la salida.
	 * <p>
	 * Procesa la peticion validando y/o complementando la informacion envíada en la request. Para ello,
	 * colabora con el Gestor de Tablas de Códigos para obtener los valores pedidos,
	 * genera el codigo html de respuesta (con mandatos javascript que actualizarán los valores de los 
	 * campos de formulario a validar), y lo devuelve a la pagina que ha llamado al servlet.
	 * 
	 * @param <code>req</code> Petición a procesar
	 * @param <code>resp</code> Respuesta a crear
	 * @throws <code>Q70ValidadorRemotoException</code>
	 * @throws <code>IOException</code>
	 */
	private void process(HttpServletRequest req, HttpServletResponse resp)
		throws Q70ValidadorRemotoException, IOException
	{		
		if (tr.isTraceActive())	
		{
			StringBuffer trBuf = new StringBuffer("Q70ValidadorRemotoListener: Procesando peticion con valores: \n");
			trBuf.append("-retFunc=").append(req.getParameter("retFunc")).append("\n")
				 .append("-targetTag=").append(req.getParameter("targetTag")).append("\n")
				 .append("-targetTagValue=").append(req.getParameter("targetTagValue")).append("\n")
				 .append("-sourceTag=").append(req.getParameter("sourceTag")).append("\n")
				 .append("-sourceTagValue=").append(req.getParameter("sourceTagValue")).append("\n")
				 .append("-table=").append(req.getParameter("table")).append("\n")
				 .append("-subjectColumn=").append(req.getParameter("subjectColumn")).append("\n")
				 .append("-predicateColumn=").append(req.getParameter("predicateColumn")).append("\n")
				 .append("-predicateColumnNumeric=").append(req.getParameter("predicateColumnNumeric")).append("\n")
				 .append("-extraPredicate=").append(req.getParameter("extraPredicate")).append("\n")
				 .append("-locale=").append(req.getLocale().toString());
				
			tr.trace(COMPONENTE, Q70TraceLevel.DEBUG, trBuf.toString()); 
		} 	
		
		
		String result = 
				getDescription(req.getParameter("targetTagValue"),
							   req.getParameter("sourceTagValue"),
							   req.getParameter("table"),
							   req.getParameter("subjectColumn"),
							   req.getParameter("predicateColumn"),
							   req.getParameter("predicateColumnNumeric"),							   
							   req.getParameter("extraPredicate"),
							   req.getLocale());

		String htmlCode = 
				composeHtmlResponse(req.getParameter("formName"), 
									req.getParameter("targetTag"),
									req.getParameter("targetTagValue"), 
									req.getParameter("sourceTag"),
									req.getParameter("sourceTagValue"),
									req.getParameter("retFunc"),
									result);
		/* componemos un tipo de retorno en función de la tecnología empleada. Si se hace la búsqueda vía
	  	   iframe componemos el retorno en código html, si se trata de tecnología iframe componemos la 
	  	   respuesta en código xml 
	  	*/
		if ((req.getParameter("technology") != null) && (req.getParameter("technology").equalsIgnoreCase(Q70Constants.IFRAME_TECH))){
			sendResponse(htmlCode, resp);
		} else {
			composeXmlResponse (req.getParameter("formName"), 
				req.getParameter("targetTag"),
				req.getParameter("targetTagValue"), 
				req.getParameter("sourceTag"),
				req.getParameter("sourceTagValue"),
				req.getParameter("retFunc"),
				result, resp);
		}
	}
	
	
	/**
	 * Este método valida y ejecuta una consulta contra el Gestor de Tablas y Codigos.
	 * Añade siempre a la parte where (o predicado) de la consulta SQL una condicion
	 * tipo: 'predicateColumn=valor' .
	 * Ej: select descrprov from provincias where codprov = 48
	 * ,donde 'predicateColumn' es la columna 'codprov' y el valor es 48.  
	 * 
	 * @param <code>targetTagValue</code> valor del tag html destino.
	 * @param <code>sourceTagValue</code> valor del tag html origen  
	 * @param <code>table</code> nombre de la tabla de la consulta 
	 * @param <code>subjectColumn</code> columna de la parte select de la consulta
	 * @param <code>predicateColumn</code> columna de la parte where de la consulta
	 * @param <code>predicateColumnNumeric</code> indica si la columna de la parte where de la consulta es numérica (true|false)
	 * @param <code>extraPredicate</code> condiciones extra a añadir a la consulta 
	 * @param <code>locale</code> configuracion local de la pagina que llamo al servlet  
	 * @return resultado de la llamada al Gestor de Tablas
	 * @throws <code>Q70ValidadorRemotoException</code>
	 */
	private String getDescription(String targetTagValue,
								  String sourceTagValue,
								  String table,
								  String subjectColumn,
							      String predicateColumn,
								  String predicateColumnNumeric,
							      String extraPredicate,
							      Locale locale ) 
		throws Q70ValidadorRemotoException							      
	{
		String result = "";								

		try 
		{							      	
			//Obtener las columnas que forman la parte 'select' (o sujeto) de la consulta a lanzar
			Vector cols = new Vector(2);
			if ((predicateColumn!=null)&&(predicateColumn.length()>0))
				cols.add(predicateColumn);
			if ((subjectColumn!=null)&&(subjectColumn.length()>0))	
				cols.add(subjectColumn);	

			//Obtener el valor correcto a pasar a la parte 'where' (o predicado) de la consulta a lanzar
			String sValue = ((null==sourceTagValue || 0==sourceTagValue.trim().length()) 
							  ? targetTagValue : sourceTagValue );

			//Componer la parte 'where' de la consulta
			StringBuffer where = new StringBuffer(64);
			if (null!=sValue && 0<sValue.trim().length())
			{
				where.append(predicateColumn);
				where.append("=");
				if (predicateColumnNumeric.equals("true"))
					where.append(sValue);	
				else
					where.append("'").append(sValue).append("'");
			}

			
			if (null!=extraPredicate && 0<extraPredicate.trim().length())
			{
				where.append((where.length()>0?" AND ":"")).append("(").append(extraPredicate).append(")");
			}
			
			if (tr.isTraceActive())	
			{
				StringBuffer trBuf = new StringBuffer("Q70ValidadorRemotoListener: Llamando al Gestor de Tablas y Codigos con valores: \n");
				trBuf.append("-table=").append(table).append("\n")
					 .append("-where=").append(where.toString()).append("\n")
					 .append("-lenguage=").append(locale.getLanguage()).append("\n")
					 .append("-cols=").append(cols.toString());
							
				tr.trace(COMPONENTE, Q70TraceLevel.DEBUG, trBuf.toString()); 
			} 	

			
			// Llamada al Gestor de Tablas y Codigos
			Collection data = (Collection) Q70GestorTablasCodigos.
										   getSingleton().
										   selectRecordsFromTable( table, 
																   where.toString(),
																   locale.getLanguage(),   
																   cols );
			if (!data.isEmpty()) 
			{
				DynaBean db = (DynaBean) data.iterator().next();			
				if (db.get(subjectColumn)!=null)
					result = (String) db.get(subjectColumn).toString();					
			}
					
		}
		catch(Q70GestorTablasException gte)
		{
			throw new Q70ValidadorRemotoException(this.getClass().toString(),
											   "getDescription",
											   "Excepcion generada por el Gestor de Tablas y Codigos",
											   gte);	
		}
		catch(Exception ex)
		{				
			throw new Q70ValidadorRemotoException(this.getClass().toString(),
											   "getDescription",
											   "Excepcion sin especificar recogida",
											   ex);
		}
		
		 		
		if (tr.isTraceActive())	
		{
			tr.trace(COMPONENTE, Q70TraceLevel.DEBUG, "Q70ValidadorRemotoListener: El resultado de la consulta contra el Gestor de Tablas y Codigos es: " + result); 
		} 
		
		
		return result;
	}
	
	
	/**
	 * Este método compone el codigo html que se va a mandar de vuelta al browser cliente.
	 * <p>
	 * Si no hay función javascript de retorno, se devuelve el resultado sobre el campo 
	 * del formulario que lo espera. Pero si la hay, se devuelve una llamada a la misma en la forma:
	 * 		funcionRetorno(codigo,resultado) 
	 * donde
	 * -codigo: valor del atributo sourceTag o resultado obtenido del Gestor de Tablas 
	 * -resultado: valor del atributo targetTag o resultado obtenido del Gestor de Tablas
	 * 
	 * Si ha habido algún error durante todo el proceso, se devuelven
	 * blancos sobre los campos del formulario a validar
	 *   
	 * @param <code>formName</code> nombre del formulario donde estan los campos
	 * @param <code>targetTag</code> nombre del tag html de destino
	 * @param <code>targetTagValue</code> valor del tag html de destino
	 * @param <code>sourceTag</code> nombre del tag html origen
	 * @param <code>sourceTagValue</code> valor del tag html origen
	 * @param <code>retFunc</code> nombre de la funcion javascript de retorno 
	 * @param <code>result</code> resultado obtenido de la llamada al Gestor de Tablas   
	 * @return código html a devolver al browser cliente
	 * @throws <code>Q70ValidadorRemotoException</code>
	 */
	private String composeHtmlResponse(String formName, 
											 String targetTag,
											 String targetTagValue, 
											 String sourceTag,
											 String sourceTagValue,
											 String retFunc,
											 String result)
		throws Q70ValidadorRemotoException												 
	{
		StringBuffer sb = null; 
			
		try
		{
			//Obtener el campo donde se devuelve la respuesta
			String returnTag = getReturnTag(sourceTag,targetTag);					
					
			sb = new StringBuffer(256);
			sb.append("<script language='JavaScript' type='text/javascript'>")
			  .append("parent.");
			
			if (null!=retFunc && 0<retFunc.length()) 
			{
				// Llamar a la funcion javascript de retorno
				if (retFunc.indexOf("()")>0) 
					retFunc.substring(retFunc.length()-2);						
				sb.append(retFunc);					
				sb.append("('");
				sb.append((returnTag.equals(sourceTag) ? result : sourceTagValue));
				sb.append("','");				
				sb.append((returnTag.equals(targetTag) ? result : targetTagValue));
				sb.append("');");					
			} 
			else if (null==result || 0==result.trim().length()) 
			{
				// Si hay algun error, devolver "vacío" en los dos campos del formulario
				if (targetTag!=null && targetTag.trim().length()>0)
					sb.append("document.").append(formName).append(".").append(targetTag).append(".value='';");

				if (sourceTag!=null && sourceTag.trim().length()>0)			
					sb.append("parent.document.").append(formName).append(".").append(sourceTag).append(".value='';");
			} 
			else 
			{
				//--------------------------------------------
				// Comportamiento por defecto de Geremua:
				//--------------------------------------------
				// Devolver el resultado obtenido				
				sb.append("document.").append(formName).append(".").append(returnTag).append(".value='").append(result).append("';");														
			}
			
			sb.append("</script>");

		} 
		catch(Exception ex) 
		{
			throw new Q70ValidadorRemotoException(this.getClass().toString(),
											   "getDescription",
											   ex.getMessage(),
											   ex);	
		}
		
		if (tr.isTraceActive())	
		{			
			tr.trace(COMPONENTE, Q70TraceLevel.DEBUG, "Q70ValidadorRemotoListener: El codigo html a devolver es: " + (null!=sb?sb.toString():"")); 
		} 	

		
		
		return (null!=sb ? sb.toString() : "");
	}
	
	/**
	 * Este método compone el codigo xml que se va a mandar de vuelta al browser cliente.
	 * <p>
	 * Si no hay función javascript de retorno, se devuelve el resultado sobre el campo 
	 * del formulario que lo espera. Pero si la hay, se devuelve una llamada a la misma en la forma:
	 * 		funcionRetorno(codigo,resultado) 
	 * donde
	 * -codigo: valor del atributo sourceTag o resultado obtenido del Gestor de Tablas 
	 * -resultado: valor del atributo targetTag o resultado obtenido del Gestor de Tablas
	 * 
	 * Si ha habido algún error durante todo el proceso, se devuelven
	 * blancos sobre los campos del formulario a validar
	 *   
	 * @param <code>formName</code> nombre del formulario donde estan los campos
	 * @param <code>targetTag</code> nombre del tag html de destino
	 * @param <code>targetTagValue</code> valor del tag html de destino
	 * @param <code>sourceTag</code> nombre del tag html origen
	 * @param <code>sourceTagValue</code> valor del tag html origen
	 * @param <code>retFunc</code> nombre de la funcion javascript de retorno 
	 * @param <code>result</code> resultado obtenido de la llamada al Gestor de Tablas   
	 * @return código html a devolver al browser cliente
	 * @throws <code>Q70ValidadorRemotoException</code>
	 */
	private String composeXmlResponse(String formName, 
											 String targetTag,
											 String targetTagValue, 
											 String sourceTag,
											 String sourceTagValue,
											 String retFunc,
											 String result,
											 HttpServletResponse response)
		throws Q70ValidadorRemotoException												 
	{
		StringBuffer sb = null; 
			
		try
		{
			//Obtener el campo donde se devuelve la respuesta
			String returnTag = getReturnTag(sourceTag,targetTag);					
			
			XMLOutputStreamFactory factory = XMLOutputStreamFactory.newInstance();
			XMLOutputStream output = factory.newOutputStream(response.getOutputStream());
			response.setContentType("text/xml");
			response.setHeader("Cache-Control", "no-cache");
			
			//abrimos el tag raíz <listenerResponse>
			output.add(ElementFactory.createStartElement("listenerResponse"));   
			output.add(ElementFactory.createCharacterData("\n"));
			
			//abrimos el tag <listener> que contendrá el componente: validador remoto
			output.add(ElementFactory.createStartElement("listener"));
			output.add(ElementFactory.createCharacterData("validadorRemoto"));
			output.add(ElementFactory.createEndElement("listener"));   
			output.add(ElementFactory.createCharacterData("\n"));
			
			output.add(ElementFactory.createStartElement("elementos"));
			output.add(ElementFactory.createCharacterData("\n"));
			
			if (result == null){
				result = "";
			} else {
				result = result.trim();
			}
			
			//abrimos tag para retorno función javascript <funcionRetorno> en su caso
			if (null!=retFunc && 0<retFunc.length()){
				// Llamar a la funcion javascript de retorno
				if (retFunc.indexOf("()")>0) {
					retFunc.substring(retFunc.length()-2);
				}
				output.add(ElementFactory.createStartElement("funcionRetorno"));
				output.add(ElementFactory.createCharacterData(retFunc));
				output.add(ElementFactory.createEndElement("funcionRetorno"));   
				output.add(ElementFactory.createCharacterData("\n"));
				
				//abrimos <tag>
				output.add(ElementFactory.createStartElement("parametro1"));
				output.add(ElementFactory.createCharacterData(returnTag.equals(sourceTag) ? result : sourceTagValue));
				output.add(ElementFactory.createEndElement("parametro1"));   
				output.add(ElementFactory.createCharacterData("\n"));
				
				//abrimos el tag <datos> en el que irá el resultado de la validación
				output.add(ElementFactory.createStartElement("parametro2"));
				output.add(ElementFactory.createCharacterData(result));
				output.add(ElementFactory.createEndElement("parametro2"));   
				output.add(ElementFactory.createCharacterData("\n"));
				
			} else {
				output.add(ElementFactory.createStartElement("formulario"));
				output.add(ElementFactory.createCharacterData(formName));
				output.add(ElementFactory.createEndElement("formulario"));   
				output.add(ElementFactory.createCharacterData("\n"));
				
				//abrimos <tag>
				output.add(ElementFactory.createStartElement("tag"));
				output.add(ElementFactory.createCharacterData(returnTag));
				output.add(ElementFactory.createEndElement("tag"));   
				output.add(ElementFactory.createCharacterData("\n"));
				
				//abrimos el tag <datos> en el que irá el resultado de la validación
				output.add(ElementFactory.createStartElement("datos"));
				output.add(ElementFactory.createCharacterData(result));
				output.add(ElementFactory.createEndElement("datos"));   
				output.add(ElementFactory.createCharacterData("\n"));
			}
			
			output.add(ElementFactory.createEndElement("elementos"));   
			output.add(ElementFactory.createCharacterData("\n"));
			
			//cerrramos el tag raíz <listenerResponse>
			output.add(ElementFactory.createEndElement("listenerResponse"));   
			output.add(ElementFactory.createCharacterData("\n"));
			
			output.flush();
			output.close();
		} 
		catch(Exception ex) 
		{
			throw new Q70ValidadorRemotoException(this.getClass().toString(),
											   "getDescription",
											   ex.getMessage(),
											   ex);	
		}
		
		if (tr.isTraceActive())	
		{			
			tr.trace(COMPONENTE, Q70TraceLevel.DEBUG, "Q70ValidadorRemotoListener: El codigo html a devolver es: " + (null!=sb?sb.toString():"")); 
		} 	

		
		
		return result;
	}
	
	 
	/**
	 * Este método envía la respuesta generada al browser cliente
	 * <p>
	 * Crea un flujo de salida hacia el browser que realizó la petición y
	 * escribe el HTML generado sobre el flujo de salida.
	 * 
	 * @param <code>htmlCode</code> Cadena HTML generada. Incluye función javaScript para actualizar los valores de
	 * los campos de formulario a validar
	 * @param <code>response</code> Respuesta a crear
	 * @throws <code>Q70ValidadorRemotoException</code>
	 */
	private void sendResponse(String htmlCode, HttpServletResponse response) 
		throws IOException
	{		
		ServletOutputStream out = response.getOutputStream();
		out.println(htmlCode);
		out.flush();   						
	}
	
	/**
	 * Este método decide sobre qué campos del formulario de entrada se devolverán los valores validados.
	 * <p>
	 * Para ello realiza las comprobaciones necesarias para obtener a qué campo 
	 * se le va a cargar el resultado devuelto por el Gestor de Tablas y Códigos.
	 * Se comprueba:
	 * - Si "sourceTagValue" es vacio, se devuelve "targetTag".
	 * - Si no y si "targetTag" no es vacio, se devuelve "targetTag".
	 * - Si no, se devuelve "sourceTag".
	 * 
	 * @param <script>sourceTag</script> nombre del campo que tiene el valor origen 
	 * @param <script>targetTag</script> nombre del campo destino del valor obtenido
	 * @return nombre del campo destino
	 */
	private String getReturnTag(String sourceTag, String targetTag)
	{		
		if (null==sourceTag || 0==sourceTag.trim().length()) 
			return targetTag;
		else if (null!=targetTag && 0<targetTag.length())
			return targetTag;
		else	
			return sourceTag;		
	}
	
}
