<?php
/* gvHIDRA. Herramienta Integral de Desarrollo Rápido de Aplicaciones de la Generalitat Valenciana
 *
 * Copyright (C) 2006 Generalitat Valenciana.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
 *
 * For more information, contact:
 *
 *  Direcció General Tecnologies de la Informació i les Comunicacions - Generalitat Valenciana
 *  http://www.dgtic.gva.es
 *  http://www.gvhidra.gva.es/
 */
/**
 * IgepComunicacion es una clase que se encarga de recoger los datos que vienen de la presentación a través de
 * POST o GET del formulario que ha realizado el submit. Estos datos se almacenan en varios repositorios dependiendo
 * de la operación a la que se vayan a destinar (inserción, actualización o borrado). Posteriormente, las clases interesadas
 * podrán recuperar estos datos por los métodos habilitados a tal efecto.
 *
 * La clase proporciona dos tipos de acceso a la información: por cursor o por matriz. El primero de ellos devuelve una
 * tupla por cada una de las solicitudes del programador. El segundo devuelve la matriz completa con todas las tuplas que
 * intervienen en la operación.
 *
 * Toda esta información vendrá en un formato adaptado para el programador, es decir los nombres de los campos de la matriz
 * serán los que corresponden a los componentes de la Tpl. De este modo el acceso a la información se realizará de una
 * forma uniforme para todos los métodos del programador.
 *
 * La información a la que puede tener acceso el programador corresponde a las siguientes operaciones básicas:
 * <ul>
 * <ui>insertar</ui>
 * <ui>borrar</ui>
 * <ui>actualizar</ui>
 * <ui>seleccionar</ui>
 * <ui>borrar</ui>
 * <ui>visibles</ui>
 * </ul>
 *
 * @license	http://opensource.org/licenses/gpl-2.0.php GNU Public License v.2
 * @version	$Id: IgepComunicacion.php,v 1.156 2011-02-21 09:45:03 afelixf Exp $
 * @author	David Pascual		<pascual_dav@externos.gva.es>
 * @author	Keka Bermejo		<bermejo_mjo@gva.es>
 * @author	Vero Navarro		<navarro_ver@externos.gva.es>
 * @author	Raquel Borjabad		<borjabad_raq@gva.es>
 * @author	Toni Felix			<felix_ant@externos.gva.es>
 *
 * @package gvHidra
 */

class IgepComunicacion
{
	/**
	 * Información del panel que llega a través del JSON.
	 *
	 * @var array
	 */
	// REDMINE #23228
	public $_infoPanel;

	/**
	 * Fila actual.
	 *
	 * @var integer
	 */
	public $int_filaSeleccionada;

	/**
	 * Matriz de datos relativos a los campos Dependientes o Calculados.
	 *
	 * @var array
	 */
	public $m_datosCamposDependientes;

	/**
	 * Matriz de datos relativos a la ventana de Seleccion.
	 *
	 * @var array
	 */
	public $m_datosVentanaSeleccion;

	/**
	 * Matriz de datos relativos a la ventana de Live Search.
	 *
	 * @var array
	 */
	public $m_datosVentanaLiveSearch;

	/**
	 * Matriz de datos visibles en el panel. Es decir que capturamos todo lo que se vea independientemente de si se les ha practicado algun cambio o no.
	 *
	 * @var array
	 */
	public $m_datos_visiblesTpl;

	/**
	 * Array de definición de los campos que aparecen en un panel
	 *
	 * @var array
	 */
	public $descCampoPanel;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos insertados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_selectedTreeTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos insertados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_insertarTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos modificados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_actualizarTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos borrados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_borrarTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos external, tanto los que puedan venir en $_REQUEST como los externos en un panel tabular de la tpl
	 *
	 * @var array
	 */
	public $m_datos_externalTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos a ser editados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_seleccionarTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos a ser editados en la tpl
	 *
	 * @var array
	 */
	public $m_datos_postConsultarTpl;

	/**
	 * Array que contiene un conjunto de punteros que recrean los datos seleccionados del padre
	 * en el método recargar. Se gasta para almacenar la tupla seleccionada por el padre para que
	 * el programador tenga acceso a esta información.
	 *
	 * @var array
	 */
	public $m_datos_seleccionarPadreTpl;

	/**
	 * Array que contiene los datos del panel de busqueda en el formato TPL
	 *
	 * @var array
	 */
	public $m_datos_buscarTpl;

	/**
	 * Array que contiene los datos de los ficheros que se han subido por Upload
	 *
	 * @var array
	 */
	public $m_datosFicherosUpLoad;

	/**
	 * Array
	 *
	 * @var array
	 */
	public $m_datos_iniciarVentanaTpl;
	// REDMINE #23348
	public $patron;
	public $int_rowSelectedLis;
	public $int_pagActive;

	/**
	 * Objeto que contiene los destinos de posibles de la acción.
	 *
	 * @var array
	 */
	private $_actionMapping;

	/**
	 * variable para acumular los errores de transformacion en data2Arrays y leerlos en checkDataTypes
	 */
	private $_transformErrors;

	/**
	 * variable para saber si desde el formulario quieren realizar la validación de datos
	 */
	private $_checkForm = 1;

	/**
	 * variable privada para identificar el panel gvhidra que está operando
	 * fil	Filtro
	 * lis	Listado
	 * edi	Ficha
	 */
	private $_panel = null;

	/**
	 * variable privada para identificar el estado del panel gvhidra que está operando
	 * R lectura
	 * W escritura
	 * I inserción
	 */
	private $_statePanel = null;

	private $_requestDataJSON = null;

	/**
	 * Constructor. Recibe como parámetro el matching con el que trabajará el objeto
	 *
	 * @access  public
	 * @param	array		$descCampoPanel
	 */
	public function __construct( $descCampoPanel = '' )
	{
		$this->descCampoPanel = $descCampoPanel;
		$this->m_auxIndices_insertar = array ();
		$this->m_auxIndices_borrar = array ();
		$this->m_auxIndices_actualizar = array ();
		$this->m_auxIndices_seleccionar = array ();

		$this->_panel = (isset($_REQUEST['gvhpanel']) ? $_REQUEST['gvhpanel'] : null);
		$this->_requestDataJSON = json_decode(@$_REQUEST['data'],true); // VERO
		// REDMINE #23228
		$this->_infoPanel = json_decode(@$_REQUEST['panel'],true); // VERO
		if (isset($_REQUEST['panel']))
		{
			$this->_infoPanel = json_decode(@$_REQUEST['panel'],true); // VERO
		}
		else {
			if (isset($this->_requestDataJSON['panel']))
			{
				$this->_infoPanel = $this->_requestDataJSON['panel'];
			}
		}
		$this->_statePanel = (isset($this->_requestDataJSON['panel']['state']) ? $this->_requestDataJSON['panel']['state'] : null);
	}

	/**************************************FUNCIONES DE CONSTRUCCIÓN**************************************/

	/**
	 * Recupera los datos de pantalla y los almacena en estructuras conocidas por el Framework.
	 * Esto permite un acceso coherente a los datos por parte del programador y del propio sistema.
	 *
	 * @access	public
	 * @return	void
	 */
	public function data2Arrays() {
		//Checkform
		if(isset($_REQUEST['checkForm'])) {
			$this->_checkForm = $_REQUEST['checkForm'];
			unset($_REQUEST['checkForm']);
		}
		if (isset($_REQUEST['gvhpanel']))
		{
            $this->_panel = $_REQUEST['gvhpanel'];
		}
		$this->data2ArraysJson();
	}


	private function fileUploadConvert($obj) {
		$arr = array();
		$this->transform_User2FW($obj->name,TIPO_CARACTER);
		$arr['name'] = $obj->name;
		$this->transform_User2FW($obj->type,TIPO_CARACTER);
		$arr['type'] = $obj->type;
		$this->transform_User2FW($obj->tmp_name,TIPO_CARACTER);
		$arr['tmp_name'] = $obj->tmp_name;
		$arr['error'] = $obj->error;
		$arr['size'] = $obj->size;
		return $arr;
	}

	private function data2ArraysJson() {
		/*La estructura de los arrays es la siguiente:
		 [data] =>
		 [fila] =>
		 [estado]=> valor, [campos]=> valor
		 */
		//Como la forma de seleccionar cambia de un Ficha a un Tabla, tenemos q comprobar de donde viene
		//Para que el indice de insertar parta de 0
	    $indexInsertar = 0;
		$filaActual = 0;
		if(isset($_REQUEST['claseManejadora'])) {
			//$claseManejadora = $_REQUEST['claseManejadora'];
			$this->_infoPanel['claseM'] = $_REQUEST['claseManejadora'];
			//Si la variable pagActual tiene valor entonces se trata de un Ficha.
			if($this->_panel=='edi') {
				if (isset($this->_requestDataJSON['panel'])) {
					// REDMINE #23228
					$this->_infoPanel = $this->_requestDataJSON['panel'];
					$filaActual = $this->_requestDataJSON['panel']['pagActive'];
				}
			}
			// REDMINE #23348
			$this->patron = $this->_requestDataJSON['panel']['patron'];
			if ($this->patron == 'TR')
			{
				$this->int_rowSelectedLis = $this->_requestDataJSON['panel']['rowSelectedLis'];
			}
		}

		$this->_transformErrors = array();
		$errs_tr = null;
		if(isset($this->_requestDataJSON['data'])) {
		    foreach ($this->_requestDataJSON['data'] as $index => $row) {
		        if (isset($row['gvhJS_state']))
		        {
    				switch($row['gvhJS_state']) {
    					case 'insertada':
    					    if($row['gvhJS_selected'] == 'selected') { // VERO
    					        if (is_array($row['gvhJS_fields']))
    					        {
            						foreach($row['gvhJS_fields'] as $name => $value) {
            							if(isset($value['CWPlugin']) && ($value['CWPlugin']=='cwupload' || $value['CWPlugin']=='cwuploadmanager'))
            							{
            								if(empty($value['files'])) {
            								    $this->m_datosFicherosUpLoad[$index][$name] = array('error' =>array('0'=>4));
            								}
            								else {
            									$val =  json_decode($value['files']);
            									$this->m_datosFicherosUpLoad[$index][$name] = $this->fileUploadConvert($val->file);
            									$this->m_datos_insertarTpl[$index][$name] = $this->fileUploadConvert($val->file);
            								}
            							}
            							else {
            								$val =  ($value['value']);
            								$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
            								if ($val != '') {
            									//m_datos_insertar
            								    $this->m_datos_insertarTpl[$index][$name] = $val;
            									//Vamos acumularlos como datos Visibles
            								    $this->m_datos_visiblesTpl[$index][$name] = $val;
            								}
            								else {
            									//Para controlar el tema de los obligatorios en estos casos lo introducimos para que salte el error
            									if(@$this->descCampoPanel[$name]['required'])
            									    $this->m_datos_insertarTpl[$index][$name] = $val;
            								}
            							}

            							if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
            							{
            							    $this->m_datos_selectedTreeTpl[$index][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
            							}
            						}
    					        }
    					        array_push($this->m_auxIndices_insertar, $index);
    					        //Para almacenar la fila actual
// REVIEW: VERO, almacenar la fila actual sólo si es panel tabular??? En panel ficha dejar a 0???
// REDMINE #23378
if($this->_panel == 'lis') {
	$this->int_filaActual = $index;
}
    					    }
    					    $indexInsertar++;
    						break;
    					case 'modificada':
    					    if (is_array($row['gvhJS_fields']))
    					    {
        						foreach($row['gvhJS_fields'] as $name => $value) {
        							if(isset($value['CWPlugin']) && ($value['CWPlugin']=='cwupload'|| $value['CWPlugin']=='cwuploadmanager'))
        							{
        								if(empty($value['files'])) {
        									$this->m_datosFicherosUpLoad[$index][$name] = array('error' =>array('0'=>4));
        								}
        								else {
        									$val =  json_decode($value['files']);
        									$this->m_datosFicherosUpLoad[$index][$name] = $this->fileUploadConvert($val->file);
        								}
        							}
        							else {
        								$val =  ($value['value']);
        								$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
        								$this->m_datos_actualizarTpl[$index][$name] = $val;
        								$valueAnterior =  ($value['valueOld']);
        								$this->transform_User2FW($valueAnterior,@$this->descCampoPanel[$name]['tipo']);
        								$this->m_datos_antiguosTpl[$index][$name] = $valueAnterior;
        								//Vamos acumularlos como datos Visibles y Seleccionados
        								$this->m_datos_visiblesTpl[$index][$name] = $val;
        								if($row['gvhJS_selected'] == 'selected') {
        								    $this->m_datos_seleccionarTpl[$index][$name] = $val;
        								    array_push($this->m_auxIndices_seleccionar, $index);
        								}
        							}

        							if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
        							{
        							    $this->m_datos_selectedTreeTpl[$index][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
        							}
        						}
        						$errs_tr = ConfigFramework::getTransformErrors();
        						array_push($this->m_auxIndices_actualizar, $index);
        						if($row['gvhJS_selected'] == 'selected')
        						{
        							$this->int_filaActual = $index;
        						}
        						else
        						{
        							$this->int_filaActual = $filaActual;
        						}
    					    }
    						break;
    					case 'borrada':
    					    if (is_array($row['gvhJS_fields']))
    					    {
        						foreach($row['gvhJS_fields'] as $name => $value) {
        							$val =  ($value['value']);
        							$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
        							$this->m_datos_borrarTpl[$index][$name] = $val;
        							$valueAnterior =  ($value['valueOld']);
        							$this->transform_User2FW($valueAnterior,@$this->descCampoPanel[$name]['tipo']);
        							$this->m_datos_antiguosTpl[$index][$name] = $valueAnterior;
        							//Vamos acumularlos como datos Visibles y Seleccionados
        							$this->m_datos_visiblesTpl[$index][$name] = $val;
        							if($row['gvhJS_selected'] == 'selected') {
        							    $this->m_datos_seleccionarTpl[$index][$name] = $val;
        							    array_push($this->m_auxIndices_seleccionar, $index);
        							}
        							if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
        							{
        							    $this->m_datos_selectedTreeTpl[$index][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
        							}
        						}
        						$errs_tr = ConfigFramework::getTransformErrors();
        						array_push($this->m_auxIndices_borrar, $index);
        						if($row['gvhJS_selected'] == 'selected')
        						{
        							$this->int_filaActual = 0;
        						}
        						else
        						{
        							$this->int_filaActual = $filaActual;
        						}
    					    }
    						break;
    					case 'nada':
    					    if (is_array($row['gvhJS_fields']))
    					    {
        						foreach($row['gvhJS_fields'] as $name => $value) {
        							$val =  ($value['value']);
        							$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
        							//Vamos acumularlos como datos Visibles
        							$this->m_datos_visiblesTpl[$index][$name] = $val;
        							if($row['gvhJS_selected'] == 'selected') {
        								$this->m_datos_seleccionarTpl[$index][$name] = $val;
        								array_push($this->m_auxIndices_seleccionar, $index);
        							}
        							if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
        							{
        							    $this->m_datos_selectedTreeTpl[$index][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
        							}
        						}
    					    }
    						break;
    					case 'buscar':
    					    if (is_array($row['gvhJS_fields']))
    					    {
        						foreach($row['gvhJS_fields'] as $name => $value) {
        							$val =  ($value['value']);
        							$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
        							//Vamos acumularlos como datos Buscar
        							$this->m_datos_buscarTpl[0][$name] = $val;
        							//Vamos acumularlos como datos Visibles
        							$this->m_datos_visiblesTpl[0][$name] = $val;

        							if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
        							{
        							    $this->m_datos_selectedTreeTpl[0][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
        							}
        							elseif(isset($value['CWPlugin']) && ($value['CWPlugin']=='cwupload'|| $value['CWPlugin']=='cwuploadmanager'))
        							{
        							    if(empty($value['files'])) {
        							        $this->m_datosFicherosUpLoad[$index][$name] = array('error' =>array('0'=>4));
        							    }
        							    else {
        							        $val =  json_decode($value['files']);
        							        $this->m_datosFicherosUpLoad[$index][$name] = $this->fileUploadConvert($val->file);
        							    }
        							}
        						}
    					    }
    						break;
    					default:
    						break;
    				}
		        }

				// si no se ha llamado a getTransformErrors (en cam), lo hago ahora
			    if (isset($errs_tr) && (is_null($errs_tr))) {
					$errs_tr = ConfigFramework::getTransformErrors();
			    }
			    if (isset($errs_tr) && !empty($errs_tr)) {
					$this->_transformErrors = array_merge($this->_transformErrors, $errs_tr);
			    }
			} //fin del foreach

			//Externals
			if(isset($this->_requestDataJSON['external']) && is_array($this->_requestDataJSON['external'])) {
				//Añadimos los externals que me pasan los plugins
			    foreach ($this->_requestDataJSON['external'] as $name => $value) {
					$val =  ($value['value']);
					$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
					$this->m_datos_externalTpl[0][$name] = $val;
				}
			}
			//Añadimos los externals que me pasan los plugins
			$this->_limpiarRequest();
			foreach ($_GET as $name => $value) {
				$this->transform_User2FW($value,TIPO_CARACTER);
				$this->m_datos_externalTpl[0][$name] = $value;
			}
		}
		$this->reset();

	} //Fin de data2ArraysJSON

	/**
	* Construye únicamente el array de Seleccionados. En este caso es importante tener en cuenta si se venimos de un panel
	* Ficha o Tabla. Esto se debe a que la forma de marcar la fila seleccionada es diferente de uno a otro (la tabla permite los checks).
	*
	* @access public
	* @return integer
	*/
	public function construirArraySeleccionar() {

		//Checkform
		if(isset($_REQUEST['checkForm'])) {
			$this->_checkForm = $_REQUEST['checkForm'];
			unset($_REQUEST['checkForm']);
		}

		$this->construirArraySeleccionarJson();
	}

	private function construirArraySeleccionarJson() {
		/*La estructura de los arrays es la siguiente:
		 [data] =>
		 [fila] =>
		 [estado]=> valor, [campos]=> valor
		 */
		//Como la forma de seleccionar cambia de un Ficha a un Tabla, tenemos q comprobar de donde viene
		//if(isset($_REQUEST['claseManejadora'])) {
		//	$claseManejadora = $_REQUEST['claseManejadora'];
		//}
		$this->_transformErrors = array();
		// REDMINE #23348
		if (isset($this->_requestDataJSON['panel']['patron']))
		{
			$this->patron = $this->_requestDataJSON['panel']['patron'];
			if ($this->patron == 'TR')
			{
				if ($this->_panel == 'lis') {
					$this->int_rowSelectedLis = $this->_requestDataJSON['panel']['rowActive'];
				}
				else {
					$this->int_rowSelectedLis = $this->_requestDataJSON['panel']['rowSelectedLis'];
				}
			}
		}
		foreach ($this->_requestDataJSON['data'] as $index => $row) {
			if (is_array($row['gvhJS_fields']))
			{
				foreach($row['gvhJS_fields'] as $name => $value) {
				    if(isset($row['gvhJS_selected']) && ($row['gvhJS_selected'] == 'selected'))
				    {
						$val =  ($value['value']);
						$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
						$this->m_datos_seleccionarTpl[$index][$name] = $val;
						array_push($this->m_auxIndices_seleccionar, $index);
						$this->int_filaActual = $index;
					}
				}
			}
			// si no se ha llamado a getTransformErrors (en cam), lo hago ahora
			$errs_tr = ConfigFramework::getTransformErrors();
			if (!empty($errs_tr)) {
				$this->_transformErrors = array_merge($this->_transformErrors, $errs_tr);
			}
		} //fin del foreach
		$this->reset();
	} //Fin de construirArraySeleccionarJson

	/**
	* método privado que utilizamos para quitar del REQUEST las variables internas de IGEP
	* @access  private
	*/
	public function _limpiarRequest() {
		unset ($_REQUEST['modActv']);
		unset ($_REQUEST['action']);
		unset ($_REQUEST[session_name()]);
		unset ($_REQUEST['claseManejadora']);
		unset ($_REQUEST['TreeMenuBranchStatus']);
		unset ($_REQUEST['checkForm']);
		unset ($_REQUEST['gvhpanel']);
	}

	public function _getPosicionRegistroPantalla($nombreCampoEnTpl) {
		//Hay que utilizar los explode porque un campo del panel Fil puede tener un _ en el nombre.
		$partesCampo = explode("___", $nombreCampoEnTpl);
		if (is_array($partesCampo) && (count($partesCampo) == 3)) {
			$subCampo = explode("_", $partesCampo[2]);
			$registro = $subCampo[1];
			//En el caso de las listas multiples tenemos que eliminar el sufijo []
			if(substr($registro,-2)=='[]')
				$registro = substr($registro,0,-2);
		}
		else {
			//Es un campo de filtro
			$registro = 0;
		}
		return ($registro);
	}


	public function construirArrayBuscar() {

		$this->construirArrayBuscarJson();
	}

	public function construirArrayBuscarJson() {
		/*La estructura de los arrays es la siguiente:
		 [data] =>
		 [fila] =>
		 [estado]=> valor, [campos]=> valor
		 */
		//Como la forma de seleccionar cambia de un Ficha a un Tabla, tenemos q comprobar de donde viene
		//if(isset($_REQUEST['claseManejadora'])) {
		//	$claseManejadora = $_REQUEST['claseManejadora'];
		//}
		$this->_transformErrors = array();

        if(is_array($_REQUEST) && (count($_REQUEST)>0)) {
            if (isset($_REQUEST['menuActv'])) {
                foreach ($_REQUEST as $prop => $val) {
                	$this->transform_User2FW($val,TIPO_CARACTER);
                	$this->m_datos_buscarTpl[0][$prop] = $val;
                }
            }
            if (isset($this->_requestDataJSON['data'][0]['gvhJS_fields']) && is_array($this->_requestDataJSON['data'][0]['gvhJS_fields'])) {
				foreach($this->_requestDataJSON['data'][0]['gvhJS_fields'] as $name => $value) {
					$val = IgepSmarty::utf8ize(($value['value']));
					$this->transform_User2FW($val,@$this->descCampoPanel[$name]['tipo']);
					$errs_tr = ConfigFramework::getTransformErrors();
					if (!empty($errs_tr)) {
						$this->_transformErrors = array_merge($this->_transformErrors, $errs_tr);
					}
					$this->m_datos_buscarTpl[0][$name] = $val;
					if (isset($value['CWPlugin']) && ($value['CWPlugin'] == 'cwarbol'))
					{
					    $this->m_datos_selectedTreeTpl[0][$name] = IgepSmarty::utf8ize($value['nodeSelected']);
					}
				}
			}

			// REDMINE #23348
			$this->patron = $this->_requestDataJSON['panel']['patron'];
        }
		$this->reset();
		return 0;
	}

	/**
	 * Carga los datos al iniciar la ventana. No tiene m_datos normal porque ningún campo puede tener matching
	 */
	public function construirArrayIniciarVentana() {
		//Limpiamos el REQUEST.
		$this->_limpiarRequest();
		$this->m_datos_iniciarVentanaTpl = null;
		foreach ($_REQUEST as $prop => $val) {
			$this->transform_User2FW($val,TIPO_CARACTER);
			$this->m_datos_iniciarVentanaTpl[0][$prop] = $val;
		}
		return 0;
	}

	/**
	* Construye el array especial para los campos Dependientes. Esta función hace uso de los métodos proporcionados por phrame.
	*
	* @access private
	*/

	public function buildDataRefreshUI($actionForm) {
		$this->m_datosCamposDependientes['formulario'] = $actionForm->get('gvHfname');
		$this->m_datosCamposDependientes['origen'] = $actionForm->get('gvHfrom');
		$this->m_datosCamposDependientes['destino'] = $actionForm->get('gvHtarget');
		$this->m_datosCamposDependientes['valor'] = $actionForm->get('gvHvalue');
		$this->m_datosCamposDependientes['claseManejadora'] = $actionForm->get('gvHclass');
		$this->m_datosCamposDependientes['estadoPanel'] = $actionForm->get('gvHpanelState');
		$this->m_datosCamposDependientes['gvhPaginando'] = $actionForm->get('gvhPaginando');

		//Calculamos la posicion del registro en la matriz.
		$posicionReal = null;
		//if (isset($_REQUEST['panel']))
		if(isset($this->_requestDataJSON['panel']))
		{
		    $panel = $this->_requestDataJSON['panel'];
    		if (!isset($panel['rowsPag']) || ($panel['rowsPag'] == -1))
    		{
    		    //es una ficha
    			if( $this->m_datosCamposDependientes['estadoPanel'] == 'I' ) {
    				//ins
    			    // $posicionReal = $this->_getPosicionRegistroPantalla($this->m_datosCamposDependientes['origen']);
    			    // Obtenemos la página de inserción ya que ya no se puede obtener descomponiendo el identificador del campo
    			    $posicionReal = $panel['pagInsercion'];
    			}
    			else {
    		    	$posicionReal = $panel['pagActive'];
    			}
    		}
    		else {
    		    //Es una tabla
    		    $position = $actionForm->get('gvhPosition');
    		    if (($position != 'panel') && ($position != '')) {
                    $regSelected = $this->_requestDataJSON['data']['gvhJS_selected'];
                    $posicionRelativa = $regSelected[0];
    		    }
    		    else {
    		    	$posicionRelativa = $this->_getPosicionRegistroPantalla($this->m_datosCamposDependientes['origen']);
    		    }
    		    $posicionReal = ($panel['pagActive']*$panel['rowsPag']) + $posicionRelativa;
    		}
		}
		$this->m_datosCamposDependientes['registroActivo'] = $posicionReal;
		unset ($_REQUEST['gvHfname']);
		unset ($_REQUEST['gvHfrom']);
		unset ($_REQUEST['gvHtarget']);
		unset ($_REQUEST['gvHvalue']);
		unset ($_REQUEST['gvHclass']);
		unset ($_REQUEST['gvHpanelState']);
	}

	public function construirArrayOrdenarTabla($actionForm) {
		$this->m_datosOrdenarTabla['claseManejadora'] = $actionForm->get('claseManejadora');
		$this->m_datosOrdenarTabla['columna'] = $actionForm->get('orderField');
		$this->m_datosOrdenarTabla['orden'] = $actionForm->get('orderTable');
		$this->m_datosOrdenarTabla['idVentana'] = $actionForm->get('idVentana');
	}

	/**
	* Método privado de igep que gastamos para construir los datos necesarios para abrir una ventana de Selección
	*
	* @access private
	*/
	public function construirArrayAbrirVentanaSeleccion($actionForm) {
		$this->m_datosVentanaSeleccion['claseManejadora'] = $actionForm->get('claseManejadora');
		//Capturamos el nombre del campo
		$campo = $actionForm->get('nomCampo');
		$this->m_datosVentanaSeleccion['nomCampo'] = $campo;
		$this->m_datosVentanaSeleccion['nomForm'] = $actionForm->get('nomForm');
		//Calculamos el índice
		$this->m_datosVentanaSeleccion['filaActual'] = $actionForm->get('filaActual');
		$this->m_datosVentanaSeleccion['panelActua'] = $actionForm->get('panelActua');
		$this->m_datosVentanaSeleccion['actionOrigen'] = $actionForm->get('actionOrigen');
		$this->m_datosVentanaSeleccion['modoPanelOrigen'] = $actionForm->get('modoPanelOrigen');
	}

	/**
	* Método privado de igep que gastamos para construir los datos necesarios para buscar en una ventana de Selección
	*
	* @access private
	* @return integer
	*/
	public function construirArrayBuscarVentanaSeleccion($actionForm) {
		$this->m_datosVentanaSeleccion['nomForm'] = $actionForm->get('nomForm');
		$this->m_datosVentanaSeleccion['nomCampo'] = $actionForm->get('nomCampo');
		$this->m_datosVentanaSeleccion['camposBusqueda'] = $actionForm->get('camposBusqueda');
		/* Redmine #23032 */
		$campoBuscar = $this->_requestDataJSON['data'][0]['gvhJS_fields']['campoBuscar']['value'];
		$this->transform_User2FW($campoBuscar,TIPO_CARACTER);
		$this->m_datosVentanaSeleccion['valor'] = $campoBuscar;
		//$this->m_datosVentanaSeleccion['valor'] = $this->_requestDataJSON['data'][0]['gvhJS_fields']['campoBuscar']['value']; //$actionForm->get('campoBuscar');
		$this->m_datosVentanaSeleccion['filaActual'] = $actionForm->get('filaActual');
		$this->m_datosVentanaSeleccion['panelActua'] = $actionForm->get('panelActua');
		$this->m_datosVentanaSeleccion['claseManejadora'] = $actionForm->get('claseManejadoraOrigen');
		$this->m_datosVentanaSeleccion['actionOrigen'] = $actionForm->get('actionOrigen');
		$this->m_datosVentanaSeleccion['modoPanelOrigen'] = $actionForm->get('modoPanelOrigen');
	}

	/**
	 * Método privado de igep que gastamos para construir los datos necesarios para abrir una ventana de Live Search
	 * @access private
	 * REDMINE #23002 Ventana Live Search
	 */
	public function construirArrayAbrirVentanaLiveSearch($field, $idField, $value, $claseM) {

	    $this->m_datosVentanaLiveSearch['claseManejadora'] = $claseM;
	    $this->m_datosVentanaLiveSearch['nomCampo'] = $field;
	    $this->m_datosVentanaLiveSearch['idCampo'] = $idField;
	    $this->transform_User2FW($value,TIPO_CARACTER);
	    $this->m_datosVentanaLiveSearch['valor'] = $value;
	}

	/**
	 * Método privado de igep que gastamos para construir los datos necesarios para buscar en una ventana de Live Search
	 *
	 * @access private
	 * @return integer
	 * REDMINE #23002 Ventana Live Search
	 */
	public function construirArrayBuscarVentanaliveSearch($actionForm) {
	    // Nombre del campo de la ventana padre
	    $this->m_datosVentanaLiveSearch['nomCampo']        = $actionForm->get('nomCampo');
	    $this->m_datosVentanaLiveSearch['camposBusqueda']  = $actionForm->get('camposBusqueda');
	    $valor = $_REQUEST['valor'];
	    $this->transform_User2FW($valor,TIPO_CARACTER);
	    $this->m_datosVentanaLiveSearch['valor'] = $valor;
	    $this->m_datosVentanaLiveSearch['filaActual']      = $actionForm->get('filaActual');
	    // Panel de la ventana padre
	    $this->m_datosVentanaLiveSearch['panelActua']      = $actionForm->get('panelActua');
	    // Clase manejadora de la ventana padre
	    $this->m_datosVentanaLiveSearch['claseManejadora'] = $actionForm->get('claseManejadoraOrigen');
	    //$this->m_datosVentanaLiveSearch['actionOrigen'] = $actionForm->get('actionOrigen');
	    // Modo del panel de la ventana padre
	    $this->m_datosVentanaLiveSearch['modoPanelOrigen'] = $actionForm->get('modoPanelOrigen');

	    $this->m_datosVentanaLiveSearch['DBSource'] = $actionForm->get('DBSource');
	}

	/*----------------------------------------------FUNCIONES DE ENTREGA----------------------------------------------*/


	/**
	* Esta funcion se encargará de realizar la validación de los datos en el servidor
	* antes de realizar una operación de inserción o actualización en la BD
	* Si ha habido errores previamente en la transformacion, estan en ConfigFramework
	*
	* @access private
	* @return int|string Devuelve 0 si no hay errores y un string con el error en caso de error.
	*/
	public function checkDataTypes() {

		$mensajeErrorValidacion = $this->_transformErrors;

		//En el caso de no tener operacion, fijamos como operacion los visibles.
		$noOperationFixed = false;
		if($this->getOperation()=='') {
			$noOperationFixed = true;
			$this->setOperation('visibles');
		}

		$datos = $this->getAllTuplas();
        $etiquetas = array();
        $mensajes = array();
		if(is_array($datos) and count($datos)>0) {
			foreach($datos as $tupla){
				foreach($tupla as $campo => $valor){
					//Si el campo tiene descripción lo validamos:
					if(isset($this->descCampoPanel[$campo]['instance'])){
						$typeValidator = unserialize($this->descCampoPanel[$campo]['instance']);
						try{
							$typeValidator->validate($valor);
						}
						catch(Exception $e){
							//Si tiene etiqueta utilizamos esa
							$nombreEtiqueta = $typeValidator->getLabel();
							$error = array();
							if(empty($nombreEtiqueta)) {
								$nombreEtiqueta = $campo;
						}
							if (!in_array($nombreEtiqueta,$etiquetas))
							{
                                $etiquetas[] = $nombreEtiqueta;
                                $error['campo'] = $nombreEtiqueta;
								$error['error'] = $e->getMessage();
								$mensajes[] = $error;
							}
						}
					}//fin del if si existe definición del campo
				}//fin del foreach de los campos de la tupla
			}//fin del foreach de las tuplas
			foreach($mensajes as $mensaje)
			{
                $mensajeErrorValidacion[] = "Campo <b>".$mensaje['campo']."</b>: <i>".$mensaje['error']."</i>";
			}
		}
		//Si no había operacion fijada, lo dejamos asi.
		$noOperationFixed = false;
		if($noOperationFixed)
			$this->setOperation('');

		if(empty($mensajeErrorValidacion))
		   return 0;
		else
		   return '<br>- '.implode('<br>- ', $mensajeErrorValidacion);
	}

	/**
	 * Devuelve los datos que con anterioridad se han recuperado y clasificado. Para ello solicita una operación y una tabla de la BD.
	 *
	 * @access	private
	 * @param	string		$operacion
	 * @param	string		$nombreTabla
	 * @return	array
	 */
	public function dameDatos( $operacion, $nombreTabla = '' )
	{
		switch( $operacion )
		{
			case 'camposDependientes' :
				return $this->m_datosCamposDependientes;
				break;
			case 'abrirVentanaLiveSearch' :
			    return $this->m_datosVentanaLiveSearch;
			    break;
			case 'buscarVentanaLiveSearch' :
			    return $this->m_datosVentanaLiveSearch;
			    break;
			case 'abrirVentanaSeleccion' :
				return $this->m_datosVentanaSeleccion;
				break;
			case 'buscarVentanaSeleccion' :
				return $this->m_datosVentanaSeleccion;
				break;
			case 'ordenarTabla' :
				return $this->m_datosOrdenarTabla;
				break;
			default :
				die('Dame Datos.Operacion desconocida.');
				break;
		}
	} //Fin de dameDatos

	/**
	 * Devuelve los datos Antiguos para una tabla dada.
	 *
	 * @access	private
	 * @param	string		$nombreTabla
	 * @return	array
	 */
	public function dameDatosAntiguos( $nombreTabla )
	{
		return $this->m_datos_antiguos[$nombreTabla];
	} //Fin de dameDatosAntiguos

	/**
	 * Retorna el valor de la fila actual
	 *
	 * @access	private
	 * @return	integer
	 */
	public function dameFilaActual()
	{
		return $this->int_filaActual;
	} //Fin de dameFilaActual

	// REDMINE #23348
	public function damePagActive()
	{
		return $this->int_pagActive;
	} //Fin de damePagActive

	public function dameRowSelectedLis()
	{
		return $this->int_rowSelectedLis;
	} //Fin de dameRowSelectedLis

	public function damePatron()
	{
		return $this->patron;
	} //Fin de damePagActive

	/*PROVISIONAL HASTA Q LO COJAMOS DE PLUGINS*/
	/**
	 * Método que devuelve el panel de trabajo de gvhidra.
	 *
	 * @deprecated
	 * @return	string		$panel		Panel de entre los tipos soportados:
	 *		<ul>
	 *			<li>fil : Filtro o modo de búsqueda ,</li>
	 *			<li>lis : Listado o modo de tabla ,</li>
	 *			<li>edi : Edición o modo de ficha.</li>
	 *		</ul>
	 */
/*	public function damePanelActivo()
	{
		IgepDebug::setDebug( WARNING, 'DEPRECATED '. __METHOD__ . '. Usar ' . __CLASS__ . '::getPanel en su lugar.' );
		return $this->getPanel();
	}*///Fin de damePanelActivo


  /************************************* NUEVO *********************************************/

	/**
	* String que contiene la operación que se está realizando
	*
	* @var string
	* @access private
	*/
	public $str_operacionActual;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de inserciones
	*
	* @var int
	* @access private
	*/
	public $int_insertarIndice;

	/**
	* Matriz de referencias a las tuplas insertadas
	*
	* @var array
	* @access private
	*/
	public $m_auxIndices_insertar;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de modificaciones
	*
	* @var int
	* @access private
	*/
	public $int_actualizarIndice;

	/**
	* Matriz de referencias a las tuplas modificadas
	*
	* @var array
	* @access private
	*/
	public $m_auxIndices_actualizar;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de borrados
	*
	* @var int
	* @access private
	*/
	public $int_borrarIndice;

	/**
	* Matriz de referencias a las tuplas borradas
	*
	* @var array
	* @access private
	*/
	public $m_auxIndices_borrar;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de seleccionados
	*
	* @var int
	* @access private
	*/
	public $int_seleccionarIndice;

	/**
	* Matriz de referencias a las tuplas seleccionadas
	*
	* @var array
	* @access private
	*/
	public $m_auxIndices_seleccionar;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de postConsultar
	*
	* @var int
	* @access private
	*/
	public $int_postConsultarIndice;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de postConsultar
	*
	* @var int
	* @access private
	*/
	public $int_seleccionarPadreIndice;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de buscar
	*
	* @var int
	* @access private
	*/
	public $int_buscarIndice;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de iniciarVentana
	*
	* @var int
	* @access private
	*/
	public $int_iniciarVentanaIndice;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de external
	*
	* @var int
	* @access private
	*/
	public $int_externalIndice;

	/**
	* Integer indice de 2o nivel para referenciar la matriz "ficticia" de visibles
	*
	* @var int
	* @access private
	*/
	public $int_visiblesIndice;

	/**
	* Este método se encarga de inicializar el indice del cursor que pertenece a la operación.
	*
	* @access  public
	* @params  $parametroOperacion la operación sobre la que se quiere reinicializar el cursor
	* @return  void
	*/
	public function reset($parametroOperacion = '') {
		//Seleccionamos la operacion
		if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
			//Inicializamos el indice de la operacion a 0
			$indice = 'int_'.$operacion.'Indice';
			$this-> $indice = 0;
		}
		else {
			$operacionesBasicas = array ('insertar', 'borrar', 'actualizar', 'seleccionar', 'external', 'visibles');
			foreach ($operacionesBasicas as $operacion) {
				$indice = 'int_'.$operacion.'Indice';
				$this-> $indice = 0;
			}
		}
	}

	/**
	 * Este método indica a la instancia cual es la operación en curso e inicializa el indice del cursor de dicha
	 * operación. La operación en curso se utilizará siempre que no se especifique como parámetro para el resto de
	 * métodos. OJO: Falta dar una lista clara de las operaciones para el usuario (internas puede haber más)
	 *
	 * @param	string		$parametroOperacion		El tipo de operación: insertar, borrar, actualizar, ... hay que dar una lista fija y clara.
	 * @return  void
	 */
	public function setOperation( $parametroOperacion )
	{
		if( ($parametroOperacion == 'visibles') && ($this->isEmpty('visibles')) )
		{
			$parametroOperacion = 'external';
		}
		$this->str_operacionActual = $parametroOperacion;
		$this->reset( $parametroOperacion );
	} //Fin de setOperacion


	/**
	 * Establece la matriz de datos para la operación actual.
	 *
	 * @param	array		$m_datos
	 */
	public function setArrayOperacion( $m_datos )
	{
		$str_operacion = $this->getOperation();
		$nombreMatriz = "m_datos_{$str_operacion}Tpl";
		if( is_array($m_datos) )
		{
			$this-> $nombreMatriz = $m_datos;
		}
		else
		{
			$this-> $nombreMatriz = array ();
		}
	} //Fin de setArrayOperacion


	/**
	* Este método permite el acceso a la propiedad interna que indica la operación actual.
	*
	* @access  public
	* @return  string
	*/
	public function getOperation() {

		return $this->str_operacionActual;
	} //Fin function getOperation

	/**
	* Este método devuelve el valor del indice del cursor sobre la operación.
	*
	* @access  public
	* @params  $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return  integer
	*/
	public function getIndex($parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$indice = 'int_'.$operacion.'Indice';
		return ($this-> $indice);
	}

	/**
	* posicionarEnTupla, coloca los índices en la fila/tupla que se le indique por parámetro
	*
	* @access private
	* @params $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return integer
	*/
	public function posicionarEnTupla($indiceFila, $parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$indice = 'int_'.$operacion.'Indice';
		if (!empty ($indiceFila))
			$this-> $indice = $indiceFila;
		else
			$this-> $indice = 0;
	}

	/**
	* Este método avanza el indice del cursor sobre la operación y lo devuelve.
	*
	* @access  private
	* @params  $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return  integer
	*/
	public function _next($parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$indice = 'int_'.$operacion.'Indice';
		$this-> $indice ++;
		return $this-> $indice;
	}

	/**
	* Este método, para un indice de cursor le devuelve el indice en la matriz de la operación.
	*
	* @access  private
	* @params  $indiceGlobal indica el valor del indice del cursor de la operación
	* @return  integer
	*/
	public function _getIndiceInterno($operacion, $indiceGlobal = -1) {
		if ($indiceGlobal == -1)
	    {
			$indiceGlobal = $this->getIndex($operacion);
	    }
		if (($operacion == 'buscar') or ($operacion == 'postConsultar') or ($operacion == 'seleccionarPadre') or ($operacion == 'external') or ($operacion == 'visibles') or ($operacion == 'iniciarVentana'))
		{
			return $indiceGlobal;
		}
		//if( ($operacion=='buscar') ) return ($indiceGlobal+1);
		//if( ($operacion=='postConsultar') or ($operacion=='seleccionarPadre') or ($operacion=='external') or ($operacion=='visibles')) return $indiceGlobal;
		$matrizAuxIndice = 'm_auxIndices_'.$operacion;
		$matrizGlobal = & $this-> $matrizAuxIndice;
		if (isset ($matrizGlobal[$indiceGlobal]))
		{
			return $matrizGlobal[$indiceGlobal];
		}
		else {
			return -1;
		}
	}

	/**
	* Este método devuelve una matriz con los campos que aparecen en la tpl para la tupla actual
	* dentro del cursor de la operacion. No avanza la posiccion en el cursor.
	*
	* @access  public
	* @params  $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return  array
	*/
	public function currentTupla($parametroOperacion = '') {
	    if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
	    }
	    else {
			$operacion = $this->getOperation();
	    }
		$nombreMatriz = 'm_datos_'.$operacion.'Tpl';
		$indiceInterno = $this->_getIndiceInterno($operacion);
		$matrizInterna = & $this-> $nombreMatriz;
		if (isset ($matrizInterna[$indiceInterno]))
		{
			//Para evitar el problema de referencias a objetos clonamos
			$row = $matrizInterna[$indiceInterno];
			foreach($row as $field => $value){
			    if(is_object($value)) {
					$row[$field] = clone $value;
				}
			}
			return $row;
		}
		else {
			return 0;
		}
	} //Fin function currentTupla

	public function getCampo($nombreCampo, $parametroOperacion = '') {
	    if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
	    }
	    else {
			$operacion = $this->getOperation();
	    }
		$resultado = $this->currentTupla($operacion);
        if (isset ($resultado[$nombreCampo])) {
			return $resultado[$nombreCampo];
		}
		else {
			return null;
		}
	} //Fin function getCampo

	// REDMINE #23120
	public function getIdBtn() {
	    if (isset ($_REQUEST['idBtn'])) {
	        $idBtn = filter_var($_REQUEST['idBtn'] ,FILTER_SANITIZE_STRING);
	        return $idBtn;
	    }
	    else {
	        return null;
	    }
	} //Fin function getIdBtn

	public function getNodeSelectedTree($nombreCampo, $parametroOperacion = '')
	{
	    $operacion = $this->getOperation();
	    $nombreMatriz = 'm_datos_'.$operacion.'Tpl';
	    $indiceInterno = $this->_getIndiceInterno($nombreMatriz);
	    if (($operacion == 'visibles') || ($indiceInterno == -1))
	        $indiceInterno = 0;
	    $matrizInterna = & $this-> m_datos_selectedTreeTpl;
	    if (isset ($matrizInterna[$indiceInterno])) {
	        //Para evitar el problema de referencias a objetos clonamos
	        $row = $matrizInterna[$indiceInterno][$nombreCampo];
	        return $row;
	    }
	    else {
	        return 0;
	    }
	} //Fin function getNodeSelectedTree


	/**
	 * Método que devuelve el nombre de la clase manejadora
	 * @return string
	 */
	// REDMINE #23228
	public function getClaseMPanel()
	{
		return $this->_infoPanel['claseM'];
	} //Fin de getClaseMPanel

	/**
	 * Este método devuelve el componente asociado al campo especificado.
	 *
	 * @access	public
	 * @param	string	$nombreCampo			El nombre del campo deseado.
	 * @return	string
	 */
	public function getComponent( $nombreCampo )
	{
		if( !isset($this->descCampoPanel[$nombreCampo])
			|| ! isset($this->descCampoPanel[$nombreCampo]['component']) )
		{
			return null;
		}

		return $this->descCampoPanel[$nombreCampo]['component'];
	} //Fin function getComponent


	/**
	 * Este método devuelve un array con los atributos del componente asociado al campo especificado.
	 *
	 * @access	public
	 * @param	string	$nombreCampo			El nombre del campo deseado.
	 * @return	array
	 */
	public function getComponentAttributes( $nombreCampo )
	{
		if( !isset($this->descCampoPanel[$nombreCampo]) )
		{
			return null;
		}

		return $this->descCampoPanel[$nombreCampo];
	} //Fin function getComponentAttributes


	/**
	* Este método devuelve el valor antiguo de una campo para la operacion activa.
	*
	* @access  public
	* @params  $nombreCampo el nombre del campo del cual se quiere conocer el valor antiguo
	* @return  string
	*/
	public function getOldValue($nombreCampo){

		$operacion = $this->getOperation();
		$indice = $this->_getIndiceInterno($operacion);
		return $this->m_datos_antiguosTpl[$indice][$nombreCampo];
	}


	/**
	 * Este método asigna el valor dado al campo
	 *
	 * @access  public
	 * @params  $nombreCampo el nombre del campo del cual se quiere conocer el valor antiguo
	 * @return  string
	 */
	public function setCampo($nombreCampo, $valorCampo, $parametroOperacion = '') {
		if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
		}
		else {
			$operacion = $this->getOperation();
		}
		$indiceInterno = $this->_getIndiceInterno($operacion);
		$nombreMatrizTpl = 'm_datos_'.$operacion.'Tpl';
		$matrizInternaTpl = & $this-> $nombreMatrizTpl;
		//Tenemos que añadirlo en el array adecuado.
		$matrizInternaTpl[$indiceInterno][$nombreCampo] = $valorCampo;
	} //Fin function setCampo

	public function setArbol($nombreCampo, $valorCampo, $parametroOperacion = '') {
		if ($parametroOperacion != '') {
	       $operacion = $parametroOperacion;
		}
		else {
	       $operacion = $this->getOperation();
		}
        $indiceInterno = $this->_getIndiceInterno($operacion);
	    $nombreMatrizTpl = 'm_datos_'.$operacion.'Tpl';
	    $matrizInternaTpl = & $this-> $nombreMatrizTpl;
	    //Tenemos que añadirlo en el array adecuado.
        $matrizInternaTpl[$indiceInterno][$nombreCampo] = $valorCampo;
	} //Fin function setArbol

	/**
	* Este método devuelve una matriz con los campos que aparecen en la tpl para la tupla actual
	* dentro del cursor de la operacion y avanza a la siguiente posición del cursor.
	*
	* @access  public
	* @params  $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return  array
	*/
	public function fetchTupla($parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$resultado = $this->currentTupla($operacion);
		$this->_next($operacion);
		return $resultado;
	} //Fin function fetchTupla

	/**
	* Este método avanza a la siguiente posición del cursor y devuelve verdadero
	* si quedan tuplas/registros en el cursor, y falso cuando se llega al final
	*
	* @access  public
	* @params  $parametroOperacion el tipo de operación, si no se indica se coge el fijado para la instancia
	* @return  boolean
	*/
	public function nextTupla($parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$this->_next($operacion);
		$resultado = $this->currentTupla($operacion);
		return (!empty ($resultado));
	} //Fin function nextTupla

	public function setTupla($tupla, $str_operacion = '') {
		if ($str_operacion != '')
			$operacion = $str_operacion;
		else
			$operacion = $this->getOperation();
		$indiceGlobal = ($ind = $this->getIndex($operacion)) > 0 ? ($ind -1) : 0;
		$indiceInterno = $this->_getIndiceInterno($operacion, $indiceGlobal);
		$nombreMatrizTpl = 'm_datos_'.$operacion.'Tpl';
		$matrizInternaTpl = & $this-> $nombreMatrizTpl;
		foreach ($tupla as $nombreCampo => $valorCampo) {
			$matrizInternaTpl[$indiceInterno][$nombreCampo] = $valorCampo;
		}
		return 1;
	} //Fin function setTupla


	/**
	 * Devuelve la matriz de datos de la operación activa.
	 *
	 * Este metodo devuelve todo el conjunto de la operacion activa. Se le puede
	 * pasar por parametro una operacion si no se quiere obtener los datos pertenecientes
	 * a la operacion activa.
	 *
	 * @param	string		$parametroOperacion		(Opcional) Indica la operacion de la que se quiere obtener la matriz.
	 * @return	mixed
	 */
	public function getAllTuplas( $parametroOperacion = '' )
	{
		$operacion = $parametroOperacion;
		$operacion = (empty($operacion) ? $this->getOperation() : $operacion);
		$this->reset( $operacion );
		$nombreMatriz = "m_datos_{$operacion}Tpl";
		if( isset($this->$nombreMatriz) )
		{
			return $this->array_values_with_clone( $this->$nombreMatriz );
		}

		return 0;
	} //Fin de getAllTuplas


	/**
	* array_values_with_clone funcion creada para evitar pasar referencias a objetos con la matriz.
	* @access private
	*
	* Esta funcion evita que pasemos referencias a objetos cuando obtenemos la matriz de datos. Esto
	* evita que si un programador modifica el objeto obtenido y luego no hace el setAllTuplas, no tenga
	* problemas con dicha modificacion.
	*
	* @param mixed $matrix matriz de datos
	* @return mixed
	*
	*/
	private function array_values_with_clone($matrix) {

		//inicializamos la variables
		$clone = false;
		$result = array();

		if(!is_array($matrix)) {
			return $result;
		}
		else {
		    if(count($matrix)==0) {
                return array();
		    }
		}

		//Comprobamos en la primera fila si tiene objetos
		$validation = $matrix[key($matrix)];
		if (is_array($validation))
			foreach($validation as $field) {
				if(is_object($field)) {
					$clone = true;
					break;
				}
			}
		reset($matrix);
		//Construimos la matriz resultado clonando si es necesario
		foreach($matrix as $row) {
			if($clone) {
				foreach($row as $field => $value) {
					if(is_object($value))
						$row[$field] = clone $value;
				}
			}
			$result[]=$row;
		}
		return $result;
	}

	/**
	* Este método devuelve todas las tuplas de antiguas para una operacion dada.
	*/
	public function getAllTuplasAntiguas($parametroOperacion = '') {

		if ($parametroOperacion != '')
	  		$operacion = $parametroOperacion;
		else
	  		$operacion = $this->getOperation();
		$this->reset($operacion);
		$indice = 0;
		$resultado = array ();
		while (($indiceInterno = $this->_getIndiceInterno($operacion)) != -1) {
			$resultado[$indice] = $this->m_datos_antiguosTpl[$indiceInterno];
			++$indice;
			$this->_next();
		}
		return $resultado;
	} //Fin de getAllTuplasAntiguas

	public function setAllTuplas($vTuplas, $parametroOperacion = '') {
		if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
		}
		else {
			$operacion = $this->getOperation();
		}
		$this->reset();
		//Si tiene más tuplas de las que teniamos borramos el contenido de la matriz TPL47
		$numTotalTuplas = 0;
		if (is_array($vTuplas))
		{
		    $numTotalTuplas = count($vTuplas);
		}
		else {
		    throw new Exception('IgepComunicacion::setAllTuplas ha de recibir un array, ahora recibe: '.var_export($vTuplas,true));
		}
		$numTuplas = 0;
		if (is_array($this->getAllTuplas($operacion)))
		{
		    $numTuplas = count($this->getAllTuplas($operacion));
		}
		if ($numTotalTuplas != $numTuplas ) {
			$matrizInternaTpl = 'm_datos_'.$operacion.'Tpl';
			$matrizInterna = 'm_datos_'.$operacion;
			$this-> $matrizInternaTpl = array ();
			$this-> $matrizInterna = array ();
			//Regeneramos el indice de las tuplas
			//$numTotalTuplas = count($vTuplas);
			$matrizAuxIndices = 'm_auxIndices_'.$operacion;
			$this-> $matrizAuxIndices = array();
			$i = 0;
			while($i<$numTotalTuplas) {
				array_push($this-> $matrizAuxIndices,$i);
				++$i;
			}
		}
		foreach ($vTuplas as $tupla) {
	  		$this->_next($operacion);
	  		$this->setTupla($tupla, $operacion);
		}
		return 1;
	} //Fin de setAllTuplas


	/**
	* Este método guarda todas las tuplas de antiguas.
	*/
	public function _setAllTuplasAntiguas($vTuplas, $parametroOperacion = '') {
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$this->reset($operacion);
		$indice = 0;
		$resultado = array ();
		while (($indiceInterno = $this->_getIndiceInterno($operacion)) != -1) {
			$this->m_datos_antiguosTpl[$indiceInterno] = $vTuplas[$indice];
			++$indice;
			$this->_next();
		}
		return $resultado;
	} //Fin de getAllTuplasAntiguas


	/**
	 * Método que devuelve los campos correspondientes a la matriz de datos de la operación activa.
	 *
	 * Este metodo devuelve los campos correspondientes a todo el conjunto de la operacion activa.
	 * Se le puede pasar por parametro una operacion si no se quiere obtener los datos pertenecientes
	 * a la operacion activa.
	 *
	 * @access	public
	 * @param	string		$parametroOperacion		Indica la operacion de la que se quiere obtener la matriz, no es obligatorio.
	 * @return	array
	 */
	public function getAllFields( $parametroOperacion='' )
	{
		$operacion = ( $parametroOperacion != '' ? $parametroOperacion : $this->getOperation() );
		$this->reset( $operacion );

		$nombreMatriz = "m_datos_{$operacion}Tpl";
		if( !isset($this->{$nombreMatriz}) || empty($this->{$nombreMatriz})
		|| !is_array($this->{$nombreMatriz}) || (is_array($this->{$nombreMatriz}) && (count($this->{$nombreMatriz}) == 0) )
		)
		{
			return 0;
		}

		return array_keys( $this->{$nombreMatriz}[0] );
	} //Fin de getAllFields


	public function setList($nombreCampo, $v_lista, $parametroOperacion = '') {
		//Este método sólo tiene sentido en un postConsultar (postBuscar, postEditar, postRecargar)
		//Por estar razón sólo se escribirá en la matriz TPL
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$indiceInterno = $this->_getIndiceInterno($operacion);
		$nombreMatrizTpl = 'm_datos_'.$operacion.'Tpl';
		$matrizInternaTpl = & $this-> $nombreMatrizTpl;
		$matrizInternaTpl[$indiceInterno][$nombreCampo] = $v_lista;
	}

	public function isEmpty($parametroOperacion = '') {
        if ($parametroOperacion != '') {
			$operacion = $parametroOperacion;
        }
        else {
			$operacion = $this->getOperation();
        }
		$nombreMatriz = 'm_datos_'.$operacion.'Tpl';
        $matriz = $this->$nombreMatriz;
        if(!isset($matriz) OR ( is_array($matriz) && count($matriz) == 0) )
		{
			return TRUE;
		}
		return FALSE;
	} //fin de isEmpty

	/** Método que devuelve para una tupla dada la información de un campo de tipo 'FILE'
	* que se ha subido al servidor.
	* @access private
	* @param string nombreCampo Nombre del campo FILE del que se quiere obtener la información
	* @param string parametroOperacion Indica la operación sobre la que se quiere la tupla
	* @return array
	*/
	public function getFileInfo($nombreCampo, $parametroOperacion)
	{
		if ($parametroOperacion != '')
			$operacion = $parametroOperacion;
		else
			$operacion = $this->getOperation();
		$indiceInterno = $this->_getIndiceInterno($operacion);
		return $this->m_datosFicherosUpLoad[$indiceInterno][$nombreCampo];
	}


	/**
	 * Metodo para conseguir que las acciones de negocio tengan acceso a mapeos diferentes a los ya especificados.
	 *
	 * @param	ActionMapping	$actionMapping
	 */
	public function setMapping( $actionMapping )
	{
		$this->_actionMapping = $actionMapping;

	} //Fin de setMapping


	/**
	 * Devuelve el nombre del forward de la acción en curso. Buscará la respuesta identificada por name en la accion actual definida en mappings.php
	 *
	 * @param	string		$name			Nombre de la respuesta deseada.
	 * @return	ActionForward
	 */
	public function getForward( $name )
	{
		//Si no existe, lanzamos excepcion que informara en el debugger del error.
		if( !$this->_actionMapping->containsKey($name) )
		{
			throw new Exception( "Error: actionForward {$name} no existe. Consulte el fichero de mapeos." );
		}

		if( isset($this->_actionMapping) )
		{
			return $this->_actionMapping->get( $name );
		}
	} //Fin de getForward


	/**
	 * Devuelve el valor de checkform para saber si se tiene que validar el formulario.
	 *
	 * @return	integer
	 */
	public function getCheckForm()
	{
		return $this->_checkForm;

	} //Fin de getCheckForm


	/**
	 * Realizar las conversiones desde formato usuario a formato FW.
	 *
	 * @access	public
	 * @param	array		$a_parametros		Vector de asociativo de elementos a transformar.
	 * @param	string		$a_tipo				Nombre de la respuesta deseada.
	 */
	public static function transform_User2FW( & $a_parametros, $a_tipo=TIPO_CARACTER )
	{
		ConfigFramework::setTransformErrors(array());
		if (empty($a_tipo) and !is_array($a_tipo))
		{
			$a_tipo = TIPO_CARACTER;
		}

		if (!is_array($a_parametros))
		{
			// le doy estructura de vector para no repetir el codigo
			$vector = false;
			$a_parametros = array(array('col'=>$a_parametros,),);
			$a_tipo = array('col'=>array('tipo'=>$a_tipo,),);
		}
		else
		{
			$vector = true;
		}

		if (is_array($a_tipo))
		{
			$transformer = new IgepTransformer(true);
			$car_i = ConfigFramework::getNumericSeparatorsUser();
			$car_n = ConfigFramework::getNumericSeparatorsFW();
			$transformer->setDecimal($car_i['DECIMAL'],$car_n['DECIMAL'],$car_i['GROUP'],$car_n['GROUP']);
			$fecha_i = ConfigFramework::getDateMaskUser();
			$fecha_n = ConfigFramework::getDateMaskFW();
			$transformer->setDate($fecha_i, $fecha_n);
			foreach ($a_parametros as $fila => $tupla)
			{
				foreach ($a_tipo as $campo => $descTipo)
				{
					$tipo_efectivo = ($descTipo['tipo']==TIPO_ENTERO? TIPO_DECIMAL: $descTipo['tipo']);
					if (empty($a_parametros[$fila][$campo]))
					{
						if($tipo_efectivo==TIPO_FECHA or $tipo_efectivo==TIPO_FECHAHORA)
						{
							$a_parametros[$fila][$campo] = null;
						}
						continue;
					}
					$num_errores = 0;
					if (is_array($transformer->getTransformErrors()))
					{
					    $num_errores = count($transformer->getTransformErrors());
					}
					$a_parametros[$fila][$campo] = $transformer->process($tipo_efectivo, $tupla[$campo]);

					if ($tipo_efectivo == TIPO_FECHA or $tipo_efectivo == TIPO_FECHAHORA)
					{
					    // REVIEW comprobación
						if (count($transformer->getTransformErrors())==$num_errores)
						{
							$a_parametros[$fila][$campo] = new gvHidraTimestamp($a_parametros[$fila][$campo]);
						}
						else
						{
							$a_parametros[$fila][$campo] = null;
						}
					}
				}
			}
			ConfigFramework::setTransformErrors($transformer->getTransformErrors());
		}
		if (!$vector)
		{
			$a_parametros = $a_parametros[0]['col'];
		}
	}//Fin IgepComunicacion

	/**
	 * Método que permite indicar el panel de trabajo activo de gvhidra.
	 *
	 * @access	public
	 * @param	string		$panel			Panel de entre los tipos soportados:
	 *		<ul>
	 *			<li>fil : Filtro o modo de búsqueda ,</li>
	 *			<li>lis : Listado o modo de tabla ,</li>
	 *			<li>edi : Edición o modo de ficha.</li>
	 *		</ul>
	 */
	public function setPanel( $panel )
	{
		$this->_panel = $panel;
	} //Fin de setPanel

	/**
	 * Método que devuelve el panel de trabajo activo de gvhidra.
	 *
	 * @return	string		$panel		Panel de entre los tipos soportados:
	 *		<ul>
	 *			<li>fil : Filtro o modo de búsqueda ,</li>
	 *			<li>lis : Listado o modo de tabla ,</li>
	 *			<li>edi : Edición o modo de ficha.</li>
	 *		</ul>
	 */
	public function getPanel()
	{
		return $this->_panel;
	} //Fin de getPanel


	/**
	 * Método que asigna el estado del panel de trabajo activo de gvhidra.
	 *
	 * @return	string		$state		Panel de entre los tipos soportados:
	 *		<ul>
	 *			<li>R : Lectura ,</li>
	 *			<li>W : Edición ,</li>
	 *			<li>I : Inserción.</li>
	 *		</ul>
	 */
	// REDMINE #23120
	public function setStatePanel($state)
	{
	    $this->_statePanel = $state;
	} //Fin de getPanel

	/**
	 * Método que devuelve el estado del panel de trabajo activo de gvhidra.
	 *
	 * @return	string		$panel		Panel de entre los tipos soportados:
	 *		<ul>
	 *			<li>R : Lectura ,</li>
	 *			<li>W : Edición ,</li>
	 *			<li>I : Inserción.</li>
	 *		</ul>
	 */
	public function getStatePanel()
	{
	    return $this->_statePanel;
	} //Fin de getPanel

} //End IgepComunicacion