<?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/
 */

/**
 * Clase destinada a manejar los parámetros de configuración de gvHidra.
 *
 * Estructurada como un patrón SINGLETON con persistencia funcional en SESION,
 * la clase servirá de base para la configuración de la organización (CUSTOM)
 *
 * @version	$Id: ConfigFramework.php 7568 2016-06-27 07:34:14Z felix_ant $
 * @author Verónica Navarro Porter: <navarro_ver@externos.gva.es>
 * @author Toni Felix: <felix_ant@externos.gva.es>
 * @author David Pascual: <pascual_dav@externos.gva.es>
 * @package gvHIDRA
 */

class ConfigFramework
{

	/**
	 * Especifica el subdirectorio custom
	 * @access private
	 * @var string
	 */
	private $customDirName;


	/**
	 * Especifica la ruta al custom
	 * @access private
	 * @var string
	 */
	private $extCustomPath;

	/**
	 * Especifica el nombre de la aplicacion
	 * @access private
	 * @var string
	 */
	private $applicationName;

	/**
	 * Especifica la versión del custom
	 * @access private
	 * @var string
	 */
	private $customVersion;

	/**
	 * Especifica la versión de la aplicacion
	 * @access private
	 * @var string
	 */
	private $appVersion;


	/**
	 * Texto personalizable de la barra superior de gvHidra
	 * @access private
	 * @var string
	 */
	private $customTitle;


	/**
	 * Texto personalizable de la barra superior de gvHidra
	 * @access private
	 * @var string
	 */
	private $barTitle;
	/**
	 * Patron singletón. Referencia a si mismo como instancia
	 * @access private
	 * @var    ConfigFramework $_instance
	 */
	private static $_instance;

	/**
	 * Propiedad que indica el estado del log.
	 * @access private
	 * @var string
	 */
	private $logStatus;

	/**
	 * Propiedad que indica el estado del log JS.
	 * @access private
	 * @var string
	 */
	private $logJSStatus;

	/**
	 * Propiedad que indica si estáo no activo el breadcrumb o ubicación
	 * @access private
	 * @var boolean
	 */
	private $enableBreadCrumb;

	/**
	 * Propiedad que indica el dsn usado para el log.
	 * @access private
	 * @var string
	 */
	private $logDSN;

	/**
	 * Propiedad que indica la seguridad del log.
	 * @access private
	 * @var string
	 */
	private $logSecurity;

	/**
	 * Propiedad que determina el tipo de consulta que vamos a realizar. Los tipos posibles son:
	 *	    - 0. Se contruye igualando los campos a los valores.
	 *      - 1. Se construye con like y comodines para cada campo.
	 *      - 2. Por defecto, se contruye con like sólo si el usuario ha especificado comodines.
	 *      - 3. Se contruye con like, case unsensitive y sin considerar las marcas diacríticas (no distingue acentos, ç,..).
	 * @access private
	 * @var string
	 */
	private $queryMode;

	/**
	 * Propiedad que determina el directorio de compilacion de las plantillas de smarty.
	 * @access private
	 * @var string
	 */
	private $templatesCompilationDir;

	/**
	 * Propiedad que determina el directorio temporal para gestion interna del FW (sesiones...)
	 * @access private
	 * @var string
	 */
	private $temporalDir;

	/**
	 * Propiedad que almacena si se recarga el fichero de mappings en cada petición
	 * @access private
	 * @var boolean
	 */
	private $reloadMappings;

	/**
	 * Propiedad que almacena si smarty tiene que comprobar si se ha modificado alguna plantilla y en caso afirmativo recargarla
	 * @access private
	 * @var boolean
	 */
	private $smartyCompileCheck;

	/**
	 * Propiedad que almacena un array asociativo (indexado por IDs) de DSNs
	 * @access private
	 * @var string
	 */
	private $vDSN;

	/**
	 * Propiedad que almacena la cadena del mensaje informativo de inicio
	 * @access private
	 * @var string
	 */
	private $startMsg;

	/**
	 * Propiedad que almacena si el mensaje de inicio es informativo o bloqueante
	 * @access private
	 * @var string
	 */
	private $startMsgType;

	/**
	 * Propiedad que contiene la definición de las listas desplegables del Custom y de la aplicación
	 * @access private
	 * @var array
	 */
	private $defList;

	/**
	 * Propiedad que contiene la definición de las ventanas de seleccion del Custom y de la aplicación
	 * @access private
	 * @var array
	 */
	private $defVS;

	/**
	 * Propiedad que contiene la definición de las campos Live Search
	 * @access private
	 * @var array
	 */
	private $defLS;

	/**
	 * Propiedad que contiene la conexion del log. Esta conexion se intentará que sea persistente (depende del SGBD, solo postgres)
	 * @access private
	 * @var object
	 */
	private $logConnection;

	/**
	 * Guarda errores del transformer
	 * @access private
	 * @var array
	 */
	private static $transformErrors = array();

	/**
	 * Indica el directorio de ubicacion de configuracion externa
	 * @access private
	 * @var array
	 */
	private $extConfigDir;

	/**
	 * Indica el fichero de configuracion externa (si existe)
	 * @access private
	 * @var array
	 */
	private $extConfigFile;


	/**
	 * Servidor de smtp
	 * @access private
	 * @var array
	 */
	private $smtpServer;

	/**
	 * Vector de properties
	 * @var array
	 */
	private $vProperties;

	/**
	 * Vector de idiomas
	 * @var array
	 */
	private $vLang;

	/**
	 * Vector de path permitidos para imágenes
	 * @var array
	 */
	private $vImgAllowedPath;

	/**
	 * String que indica el lenguaje por defecto
	 * @var array
	 */
	private $currentLang;

	/**
	 * Booleano para indicar si el i18n esta activado
	 * @var array
	 */
	private $activeLang;

	/**
	 * String que indica el path completo del fichero changelog
	 * @var string
	 */
	private $changelogFile;


	/** @var string Constante para indicar codificación por defecto en el cliente DB*/
	const DEFAULT_DBCLIENT_ENCODING = 'UTF-8';
	/** @property array Array de equivalencias de nombre para la codificación ISO-8859-1 y/o ISO-8859-15 */
	private static $v_latin 	= array ('ISO-8859-1',	'ISO8859-1',	'iso-8859-1',	'iso8859-1',	'latin1', 'ISO-8859-15',	'ISO8859-15',	'iso-8859-15',	'iso8859-15',	'latin9');
	/** @property array Array de equivalencias de nombre para la codificación UTF-8 */
	private static $v_unicode = array ('UTF-8', 'UTF8', 'utf-8','utf8', 'UNICODE', 'unicode');


	private function __construct()
	{
		$this->logStatus = LOG_NONE;
		$this->logJSStatus = LOG_NONE;
		$this->enableBreadCrumb = false;
		$this->queryMode = 2;
		$this->defList = array();
		$this->defVS = array();
		$this->defLS = array();
		$this->vDSN = array();
		$this->templatesCompilationDir = 'templates_c/';
		$this->temporalDir = null;
		$this->reloadMappings = null;
		$this->smartyCompileCheck = null;
		$this->logDSN = 'gvh_dsn_log';
		$this->logSecurity = null;
		$this->startMsg = '';
		$this->startMsgType = 'info';
		$this->currentLang = false;
		$this->activeLang = false;
		$this->changelogFile = "";
	}

	public function __destruct()
	{
		//Almacenamos la configuración en la SESSION siempre que exista la aplicación (Cuando se cierra la aplicación no la guardamos)
		if (IgepSession::existeAplicacion($this->applicationName))
		{
			if (is_object($this->logConnection))
			{
				if (method_exists($this->logConnection, 'getDriver'))
				{
					if ($this->logConnection->getDriver()=='pdo')
					{
						$this->logConnection = null;
					}
				}
				elseif (method_exists($this->logConnection, 'close'))
				{
					$this->logConnection = null;
				}
			}
			try
			{
				$_SESSION[$this->applicationName]['configuration'] = serialize(self::$_instance);
			}
			catch(Exception $e) {}
		}
	}//Fin destructor

	/**
	 * Método getConfig
	 *
	 * Devuelve el objeto singleton asociado a la clase
	 *
	 * @access public static
	 * @return ConfigFramework
	 */
	public static function getConfig()
	{
		//Cargamos el fichero de configuración del Framework
		try
		{
			//Comprobar que existe el fichero y cargarlo
			if (empty(self::$_instance))//Review: David y Toni: Clase Pear:Config para cargar fichero
			{
				$g_aplicacion = self::getApplicationName();
				if(!isset($_SESSION[$g_aplicacion]['configuration']))
				{
					$instance = new ConfigFramework();

					//Leemos el fichero de configuración del Framework
					$fichero = './igep/gvHidraConfig.inc.xml';
					$instance->_loadConfigFile($fichero);

					//Leemos el fichero de configuración del CUSTOM
					// REDMINE #23171
					$custom = $instance->getCustomPath();
					$fichero = $custom . '/gvHidraConfig.inc.xml';
					$instance->_loadConfigFile($fichero);

					//Leemos el fichero de configuración de la APLICACIÓN
					$fichero = './gvHidraConfig.inc.xml';
					$instance->_loadConfigFile($fichero);

					//Leemos el include externo si existe
					$extConfigFile =$instance->getExtConfigFile();
					if(!empty($extConfigFile))
					{
						$fichero = $extConfigFile;
						if(file_exists($fichero))
						{
							$instance->_loadConfigFile($fichero);
						}
						else
						{
							throw new Exception('ConfigFramework::getConfig() EXCEPCION: no se puede acceder al fichero de configuración externa: '.$fichero);
						}
						//Volvemos a leer el fichero interno (versión y CUSTOM propios
						$instance->_loadConfigFile('./gvHidraConfig.inc.xml');
					}

					self::$_instance = $instance;
					$_SESSION[$g_aplicacion]['configuration'] = serialize($instance);
				}
				else
				{
					self::$_instance = unserialize($_SESSION[$g_aplicacion]['configuration']);
				}
			}
			return self::$_instance;
		}
		catch (Exception $e)
		{
			throw new Exception('ConfigFramework::getConfig() EXCEPCION: error en la lectura de los ficheros: '.$e->getMessage());
		}
	}//Fin getConfig (constructor singleton)


    /**
	 * getCustomDirName:: Devuelve el nombre del subdirectorio de CUSTOM actual
	 *
	 * Devuelve el directorio que contiene la información de custom
	 *
	 * @access public static
	 * @return string
	*/
	public static function getCustomDirName()
	{
		// REDMINE #23171
		if(!empty(self::$_instance)) return self::$_instance->customDirName;

        $files = array('./igep/gvHidraConfig.inc.xml', './gvHidraConfig.inc.xml');
        $externalConfig = self::getExtConfigFile();
        if(!empty($externalConfig)) array_push($files, $externalConfig);

		$customName = '';
		foreach ($files as $file)
		{
			if (!file_exists($file)) continue;
			$customDirName = self::getStringFromXML($file, 'customDirName');
			if (!empty($customDirName)) $customName = $customDirName;
		}

		if (empty($customName))
		{
			throw new Exception(__CLASS__ . '::' . __METHOD__ .
				': no se ha definido el elemento CUSTOM a utilizar ');
		}

		return $customName;
	}

	/**
	* setCustomDirName:: Fija el nombre del subdirectorio de CUSTOM actual
	*
	* @param string customDirName nombre del directorio
	* @access public static
	*/
	public static function setCustomDirName($customDirName)
	{
		//Si no es vacio
		if(!empty($customDirName)) {
			// REDMINE #23171
			$parentDir = self::getCustomsPath();
			self::$_instance->customDirName = $customDirName;
			self::$_instance->extCustomPath = $parentDir . $customDirName;
		    //$fichero = './custom/'.$customDirName.'/gvHidraConfig.inc.xml';
		    $fichero = './'. self::getCustomsPath() . $customDirName . '/gvHidraConfig.inc.xml';
		    self::$_instance->_loadConfigFile($fichero);
		}
	}

	/**
	 * getCustomPath:: Devuelve la ruta donde se ubica el CUSTOM actual
	 *
	 * Devuelve el directorio que contiene la información de custom
	 *
	 * @access public static
	 */
    public static function getCustomPath()
    {
    	// REDMINE #23171
        if(!empty(self::$_instance)) return self::$_instance->extCustomPath;

        $ficheros = array('./igep/gvHidraConfig.inc.xml','./gvHidraConfig.inc.xml');
        $externalConfig = self::getExtConfigFile();
        if(!empty($externalConfig)) array_push($ficheros, $externalConfig);

		$customPath = "";
        foreach ($ficheros as $fichero)
        {
            if (!file_exists($fichero)) continue;

            $sXML = simplexml_load_file($fichero);
            if(!empty($sXML->customDirName))
            {
                $nombreCustom = (string) $sXML->customDirName;
                $vAtributos = $sXML->customDirName->attributes();
                // REDMINE #23171
                $customPath  = !empty($vAtributos['path']) ? ($vAtributos->path."/".$nombreCustom) : ('custom/'.$nombreCustom);
            }
            unset($sXML);
        }

		if (empty($customPath))
		{
			throw new Exception(
				__CLASS__ . '::' . __FUNCTION__ . ': ' .
				'La etiqueta "customDirName" no ha sido definida.'
			);
		}

		return $customPath;
	}//Fin getCustomPath


    /**
     * getCustomsPath:: Devuelve la ruta del directorio
     * donde se ubican los customs
     *
     * @access public static
     *
     * @return string
     */
	// REDMINE #23171
    public static function getCustomsPath() {
        return dirname(self::getCustomPath()) . "/";
    }// Fin getCustomsPath

	/**
	 * getApplicationName:: Devuelve el nombre de la aplicación actual
	 *
	 * @return string Nombre de la aplicación
	 * @access public
	*/
	public static function getApplicationName()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}
			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$sXML = simplexml_load_file($fichero);
					if(!empty($sXML->applicationName))
					{
						$nombreApp = (string) $sXML->applicationName;
					}
				}
				else
				{
					throw new Exception('getApplicationName: no existe el fichero '.$fichero);
				}
			}
			if (!empty($nombreApp))
			{
				return($nombreApp);
			}
			throw new Exception('getApplicationName: no está definido el codigo de la aplicación');
		}
		return self::$_instance->applicationName;
	}


    /**
	 * setApplicationName: Establece el nombre de aplicación
	 *
	 * Establece el nombre de aplicación actual
	 * @param string $appName Cadena que indica el nombre de la aplicacion
	 *
	*/
	private function setApplicationName($appName)
	{
		$this->applicationName = $appName;
	}


	/**
	 * getAppVersion:: Devuelve la versión de la aplicación
	 *
	 * Devuelve el número de versión de la aplicación. En desarrollo devolverá HEAD.
	 * @return string Texto con la versión de la aplicación
	 * @access public
	*/
	public static function getAppVersion()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros[] = $externalConfig;
			}
			$appVersion ='';
			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
						$aux = self::getStringFromXML($fichero,'appVersion');
						if(!empty($aux))
							$appVersion = $aux;
				}
			}
			if (!empty($appVersion))
			{
				return($appVersion);
			}
			else
			{
				throw new Exception('getAppVersion: Debe definir la versión en al menos uno de los ficheros de configuración');
			}
		}
		return self::$_instance->appVersion;
	}

	/**
	 * getgvHidraVersion:: Devuelve la versión de gvHidra
	 *
	 * Devuelve el número de versión del framework gvHidra.
	 * @return string Texto con la versión de la aplicación
	*/
	public function getgvHidraVersion()
	{
		return($this->gvHidraVersion);
	}

	/**
	 * getCustomVersion:: Devuelve la versión del custom
	 *
	 * Devuelve el número de versión del framework gvHidra.
	 * @return string Texto con la versión de la aplicación
	 */
	public function getCustomVersion()
	{
	    return($this->customVersion);
	}

	/**
	 * getExtConfigDir:: Devuelve la ubicación del fichero de configuración externa.
	 *
	 * Para poder ubicar el fichero de configuración. Puede utilizarse para ubicarlo fuera del htdocs por seguridad.
	 * @return string Texto con la ruta
	*/
	public static function getExtConfigDir()
	{
		if(empty(self::$_instance))
		{
			$fichero = './gvHidraConfig.inc.xml';
			if (file_exists($fichero))
			{
				$extConfigDir = self::getStringFromXML($fichero,'extConfigDir');
				if (!empty($extConfigDir)) return($extConfigDir);
			}
			else
			{
				throw new Exception('getExtConfigDir: no existe el fichero '.$fichero);
			}
			return null;
		}
		return (self::$_instance->extConfigDir);
	}

	/**
	 * getExtConfigFile:: Devuelve la ruta canónica al fichero de configuración externo o null si no se usa fichero externo
	 *
	 * Para realizar ajuste de configuración se requiere poder ubicar el ficher de configuración
	 *
	 * Utilizada para mostrar mensajes en la pantalla de validación
	 * @return string Texto informativo
	 */
	public static function getExtConfigFile()
	{
		if(empty(self::$_instance))
		{
			$extConfigFile = './gvHidraConfig.inc.xml';
			// REDMINE #23171
			if (file_exists($extConfigFile))
			{
			    $sXML = simplexml_load_file($extConfigFile);
				$extConfigDir = (string) $sXML->extConfigDir;
				if(empty($extConfigDir)) return null;

				$v_atributos = $sXML->extConfigDir->attributes();
				if (!empty($v_atributos['fileName']))
				{
					$extConfigFile = realpath ($extConfigDir).DIRECTORY_SEPARATOR.$v_atributos->fileName;
				}

				if (!empty($extConfigFile))
				{
					return($extConfigFile);
				}
				else
				{
					throw new Exception(__CLASS__.'::'.__FUNCTION__.': no existe la ruta '.$extConfigFile);
				}
			}
			throw new Exception(__CLASS__.'::'.__FUNCTION__.': no está definido la ruta en la aplicación');
		}
		// Hemos quitado el $
		return self::$_instance->extConfigFile;
	}//Fin getExtConfigFile

    /**
	 * setApplicationName: Fija la versión que se esta ejecutando.
	 *
	 * Establece la versión de la aplicación que se esta ejecutando.
	 * @param string $appVersion Cadena que indica la versión de la aplicación
	 *
	*/
	public function setAppVersion($appVersion)
	{
		$this->appVersion = $appVersion;
	}

	/**
	 * getStartMsg:: Devuelve cadena de texto informativa de arranque o cadena vacía
	 *
	 * Utilizada para mostrar mensajes en la pantalla de validación
	 * @return string Texto informativo
	 */
	public static function getStartMsg()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}
			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$sXML = simplexml_load_file($fichero);
					$startMsg = $sXML->startMsg;
					$cadenaMsg = (string) $startMsg;
					unset($sXML);//Liberamos el recurso

					if(!empty($cadenaMsg))
						return($cadenaMsg);
					else return ('');
				}
				else
				{
					throw new Exception(__CLASS__.'::'.__FUNCTION__.': no existe el fichero '.$fichero);
				}
			}
			throw new Exception(__CLASS__.'::'.__FUNCTION__.': no está definido el título de la aplicación');
		}
		return self::$_instance->startMsg;
	}


	/**
	 * getStartMsgType:: Devuelve el tipo de mensaje (informativo o bloqueante)
	 *
	 * Utilizada para mostrar mensajes en la pantalla de validación
	 * @return mixed tipo del mensaje 'info'|'lock' si existe o null si no existe
	 */
	public static function getStartMsgType()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}
			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$sXML = simplexml_load_file($fichero);
					$startMsg = $sXML->startMsg;
					if (count($startMsg)==0) return null;//No hay Mensaje
					$vAtributos = $startMsg->attributes();
					$startMsgType = (string) $vAtributos['type'];
					unset($sXML);//Liberamos el recurso

					if(!empty($startMsgType))
						return(trim(mb_strtolower($startMsgType, 'UTF-8')));
					else return ('info');
				}
				else
				{
					throw new Exception(__CLASS__.'::'.__FUNCTION__.': no existe el fichero '.$fichero);
				}
			}
			throw new Exception(__CLASS__.'::'.__FUNCTION__.': no está definido el título de la aplicación');
		}
		return self::$_instance->startMsgType;
	}


	/**
	 * setStartMsg: Fija el texto informativo del mensaje
	 *
	 * @access public
	 * @param string $msg Cadena con el texto informativo
	 * @param string $type Cadena con el tipo de mensaje
	 *
	 */
	public function setStartMsg($msg, $type='info')
	{
		$this->startMsg = $msg;
		$this->startMsgType = 'info';
		if (trim(strtolower($type)) == 'lock')
		{
			$this->startMsgType = 'lock';
		}
	}


	/**
	 * getCustomTitle:: Devuelve la cadena de descripción de la aplicación fijada en el XML
	 *
	 * Si se desea, puede fijarse la descricpión de la aplicación vía XML en el fichero y
	 * cargarse en sesión. Los métodos de validación podrán sobreescribir este valor con
	 * información obtenida tras la validación
	 * Este método permite acceder a dicho valor
	 * @return string Texto de personalización de la barra superior
	 * @access public
	*/
	public static function getCustomTitle()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}

			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$aux = self::getStringFromXML($fichero,'customTitle');

					if(!empty($aux))
					{
						return($aux);
					}

					else
					{
						return ('');
					}
				}
				else
				{
					throw new Exception('getCustomTitle: no existe el fichero '.$fichero);
				}
			}
			throw new Exception('getCustomTitle: no está definido el título de la aplicación');
		}
		return self::$_instance->customTitle;
	}


    /**
	 * setCustomTitle: Sobrescribe la cadena de descripción de la aplicación leída en el XML
	 *
	 * @access public
	 * @param string $customTitle Cadena con el breve texto de personalización
	 *
	*/
	public function setCustomTitle($customTitle)
	{
		$this->customTitle = $customTitle;
	}

	/**
	 * getBarTitle:: Devuelve la cadena de personalización de la barra superior
	 *
	 * En la barra superior se ha designado un pequeño espacio para	un texto personalizado.
	 * Este método permite acceder a dicho valor
	 * @return string Texto de personalización de la barra superior
	 * @access public
	 */
	public static function getBarTitle()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}

			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$aux = self::getStringFromXML($fichero,'barTitle');

					if(!empty($aux))
					{
						return($aux);
					}

					else
					{
						return ('');
					}
				}
				else
				{
					throw new Exception('getBarTitle: no existe el fichero '.$fichero);
				}
			}
			throw new Exception('getBarTitle: no está definido el texto');
		}
		return self::$_instance->barTitle;
	}


	/**
	 * isActivatedi18n: Indica si esta activada la i18n
	 *
	 * Se utiliza de forma estática para facilitar información en el proceso de validación por si se requiere validación multiidioma.
	 *
	 * @access public
	 * @return bool
	 */
	public static function isActivatedi18n() {

		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}

			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$sXML = simplexml_load_file($fichero);
					if ($sXML->LangZone)
					{
						$vAtributosLangZone = $sXML->LangZone->attributes();
						return ((string) $vAtributosLangZone['activate'] == 'true')?true:false;
					}
					return false;
				}
				else
				{
					throw new Exception('getActivatedi18n: no existe el fichero '.$fichero);
				}
			}
		}
		return self::$_instance->activeLang;
	}


	/**
	 * setBarTitle: Fija el texto personalizado de la barra de título
	 *
	 * @access public
	 * @param string $barTitle Cadena con el breve texto de personalización
	 *
	 */
	public function setBarTitle($barTitle)
	{
		$this->barTitle = $barTitle;
	}//Fin setBarTitle

	/**
	 * getLogStatus:: Devuelve el estado del log.
	 *
	 * Devuelve el estado del log en la aplicación. Los valores posibles son LOG_NONE, LOG_ERRORS, LOG_AUDIT y LOG_ALL.
	 * @access public
	*/
	public function getLogStatus()
	{
		return($this->logStatus);
	}

	/**
	 * getIdLogDSN:: Devuelve el id del dsn del log
	 *
	 * @access public
	 */
	public function getIdLogDSN()
	{
		return($this->logDSN);
	}

    /**
	 * setLogStatus: Fija el estado del log.
	 *
	 * Establece el estado del log. Los valores posibles son LOG_NONE, LOG_ERRORS, LOG_AUDIT y LOG_ALL.
	 * @access public
	 * @param string $status contiene el nuevo estado del log.
	 *
	*/
	public function setLogStatus($status)
	{
		if ($status>=LOG_NONE && $status<=LOG_ALL)
		{
			$this->logStatus=$status;
		}
		else {
			throw new Exception('setLogStatus: Error al fijar logStatus.');
		}
	}

	/**
	 * getLogStatus:: Devuelve el estado del log.
	 *
	 * Devuelve el estado del log en la aplicación. Los valores posibles son LOG_NONE, LOG_ERRORS, LOG_AUDIT y LOG_ALL.
	 * @access public
	 */
	public function getLogJSStatus()
	{
	    return($this->logJSStatus);
	}


	/**
	 * setLogStatus: Fija el estado del log.
	 *
	 * Establece el estado del log. Los valores posibles son LOG_NONE, LOG_ERRORS, LOG_AUDIT y LOG_ALL.
	 * @access public
	 * @param string $status contiene el nuevo estado del log.
	 *
	 */
	public function setLogJSStatus($status)
	{
		if (($status>=LOG_NONE) && ($status<=LOG_ALL)) {
	        $this->logJSStatus=$status;
		}
		else {
            throw new Exception('setLogJSStatus: Error al fijar logJSStatus.');
		}
	}

	/**
	 * isEnableBreadCrumb: Devuelve si está o no activo el breadCrumb
	 *
	 * @return boolean
	 */
	public function isEnableBreadCrumb()
	{
		return($this->enableBreadCrumb);
	}


	/**
	 * getQueryMode:: Devuelve el valor del modo de consulta (ver propiedad para var posibles valores).
	 *
	 * Devuelve el valor del modo de consulta para saber de que modo se van a construir las Querys.
	 * @access public
	*/
	public function getQueryMode()
	{
		return($this->queryMode);
	}

    /**
	 * setQueryMode: Fija el valor del modo de consulta (ver propiedad para var posibles valores)
	 *
	 * Fija el valor del modo de consulta para saber de que modo se van a construir las Querys.
	 * @access public
	 * @param string $mode contiene el nuevo modo de consulta.
	 *
	*/
	public function setQueryMode($mode)
	{
		if ($mode>=0 && $mode<=2)
			$this->queryMode=$mode;
		else
			throw new Exception('setQueryMode: Error al fijar queryMode.');
	}


	/**
	 * getTemplatesCompilationDir:: Devuelve el directorio de templates_c
	 *
	 * Devuelve el directorio de compilacion de las plantillas de smarty.
	 * @access public
	*/
	public function getTemplatesCompilationDir()
	{
		return($this->templatesCompilationDir);
	}


    /**
	 * setTemplatesCompilationDir: Fija el directorio de templates_c
	 *
	 * Establece el directorio de compilacion de las plantillas de smarty.
	 * @access public
	 * @param string $dir directorio de compilacion de plantillas
	 *
	*/
	public function setTemplatesCompilationDir($dir)
	{
		$this->templatesCompilationDir = $dir;
	}

	/**
	 * getTemporalDir: Devuelve la ruta del directorio temporal del FW
	 *
	 * Devuelve la ruta del directorio temporal del FW.
	 * Si no existe la instancia lo coge del xml de aplicacion. No hay metodo setter.
	 * @access public
	*/
	public static function getTemporalDir()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}
			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$tmp = self::getStringFromXML($fichero,'temporalDir');
					return($tmp);
	    		}
	    		else
	    		{
					throw new gvHidraException("getTemporalDir:: no existe el fichero $fichero");
	    		}
			}
		}
		return self::$_instance->temporalDir;
	}

	/**
	 * setTemporalDir: Fija el directorio temporal
	 *
	 * Establece el directorio temporal para el FW
	 * @access public
	 * @param string $dir directorio temporal
	 *
	 */
	public function setTemporalDir($dir)
	{
	    $this->temporalDir = realpath($dir);
	}

	/**
	 * getLogConnection: Devuelve la conexion que se utiliza en el log.
	 *
	 * Devuelve el objeto conexion que se utiliza en el debug/log del FW. Esta conexion será persistente dependiendo
	 * del SGBD (solo Postgres lo permite).
	 * @access public
	*/
	public function getLogConnection()
	{
		return $this->logConnection;
	}

	/**
	 * setLogConnection: Fija la conexion que se utiliza en el log.
	 *
	 * Fija el objeto conexion que utilizara el log para trabajar. Esta conexion será persistente dependiendo
	 * del SGBD (solo Postgres lo permite).
	 *
	 * Uso interno del FW. NO DEBE SER USUADO POR EL PROGRAMADOR
	 *
	 * @access public
	*/
	public function setLogConnection($connection)
	{
		$this->logConnection = $connection;
	}

	/**
	 * getReloadMappings: Devuelve el valor del estado de reloadMappings
	 *
	 * @access public
	*/
	public function getReloadMappings()
	{
		return($this->reloadMappings);
	}


    /**
	 * setReloadMappings: Fija el estado de reloadMappings
	 *
	 * @access public
	 * @param string $mode contiene el nuevo estado
	 *
	*/
	public function setReloadMappings($mode)
	{
		if (is_bool($mode))
			$this->reloadMappings=$mode;
		else
			throw new Exception('setReloadMappings: Error al fijar reloadMappings.');
	}

	/**
	 * getSmartyCompileCheck: Devuelve el valor de smartyCompileCheck
	 *
	 * @access public
	*/
	public function getSmartyCompileCheck()
	{
		return($this->smartyCompileCheck);
	}


	/**
	 * getProperties: Devuelve un array asociativo de "properties"
	 *
	 * Devuelve un array asociativo lcave/valor (propertie/value) de las
	 * properties definidas en el ficheros gvHidraConfig.inc.xml
	 * @return Array Vector asociativo de properties
	 */
	public function getProperties()
	{
		return($this->vProperties);
	}//Fin getProperties


	/**
	 * getProperty: Devuelve el valor de la propiedad pasada por parámetro
	 *
	 * @param string $property Clave de la property
	 * @return mixed String o null si no existe la propiedad
	 */
	public function getProperty($property)
	{
		if( is_array($this->vProperties) && array_key_exists($property, $this->vProperties))
			return ($this->vProperties[$property]);

		return null;
	}//Fin getProperty


	/* ------------------------------------------------------------------------ */
	/* ----------------------------- MÉTODOS PRIVADOS ------------------------- */
	/* ------------------------------------------------------------------------ */

	/**
	 * _loadConfigFile: Carga un fichero de configuración XML
	 *
	 *  Carga el fichero de configuración XML indicado por parámetro y asigna
	 *  los valores leídos en el mismo en la instancia del objeto
	 * @access private
	 * @param string $fichero
	*/
	private function _loadConfigFile($fichero)
	{
		try
		{
			if (file_exists($fichero))
			{
				$sXML = simplexml_load_file($fichero);

				if ($sXML->changelogFile)
					$this->changelogFile =  (string) $sXML->changelogFile;

				if ($sXML->applicationName)
					$this->applicationName =  (string) $sXML->applicationName;

				if ($sXML->templatesCompilationDir)
					$this->templatesCompilationDir =  (string) $sXML->templatesCompilationDir;

				if ($sXML->temporalDir)
					$this->temporalDir =  (string) $sXML->temporalDir;

				if ($sXML->reloadMappings)
					$this->reloadMappings = (boolean)(strtolower((string) $sXML->reloadMappings)=='true');

				if ($sXML->smartyCompileCheck)
					$this->smartyCompileCheck = (boolean)(strtolower((string) $sXML->smartyCompileCheck)=='true');

				if ($sXML->appVersion)
					$this->appVersion = (string) $sXML->appVersion;

				if ($sXML->customVersion)
				    $this->customVersion = (string) $sXML->customVersion;

				if ($sXML->gvHidraVersion)
					$this->gvHidraVersion = (string) $sXML->gvHidraVersion;

				if ($sXML->customTitle)
					$this->customTitle = (string) $sXML->customTitle;

				if ($sXML->barTitle)
					$this->barTitle = (string) $sXML->barTitle;

				if ($sXML->customDirName)
				{
					$this->customDirName =  (string) $sXML->customDirName;
					$vAtributos = $sXML->customDirName->attributes();
					// REDMINE #23171
					$customPath  = !empty($vAtributos->path) ? ($vAtributos->path."/".$this->customDirName) : ('custom/'.$this->customDirName);
					$this->extCustomPath = $customPath;
				}

                if ($sXML->extConfigDir)
				{
					$this->extConfigDir =  (string) $sXML->extConfigDir;
					$vAtributos = $sXML->extConfigDir->attributes();
					$this->extConfigFile = realpath ($this->extConfigDir).DIRECTORY_SEPARATOR.$vAtributos->fileName;
				}

				//logSettings
				if ($sXML->logSettings)
				{
					$vAtributos = $sXML->logSettings->attributes();
					$estadoLog = (string) $vAtributos['status'];
					switch ($estadoLog)
					{
						case 'LOG_ERRORS':
							$this->logStatus = LOG_ERRORS;
						break;
						case 'LOG_AUDIT':
							$this->logStatus = LOG_AUDIT;
						break;
						case 'LOG_ALL':
							$this->logStatus = LOG_ALL;
						break;
						default:
							$this->logStatus = LOG_NONE;
					}//Fin switch
					$dsnRef = (string) $vAtributos['dsnRef'];
					if (!empty($dsnRef))
						$this->logDSN = $dsnRef;
					$security = (string) $vAtributos['security'];
					if (!empty($security))
						$this->logSecurity = $security;
				}//Fin if logSettings

				//logJSSettings
				if ($sXML->logJSSettings)
				{
				    $vAtributos = $sXML->logJSSettings->attributes();
				    $estadoJSLog = (string) $vAtributos['status'];
				    $this->logJSStatus = $estadoJSLog;
				  /*  switch ($estadoLog)
				    {
				        case 'LOG_ERRORS':
				            $this->logJSStatus = LOG_ERRORS;
				            break;
				        case 'LOG_AUDIT':
				            $this->logJSStatus = LOG_AUDIT;
				            break;
				        case 'LOG_ALL':
				            $this->logJSStatus = LOG_ALL;
				            break;
				        default:
				            $this->logJSStatus = LOG_NONE;
				    }//Fin switch*/
				}//Fin if logJSSettings

				//Breadcrumb o ubicación
				$this->enableBreadCrumb = false;
				if ($sXML->breadcrumb)
				{
					$vAtributos = $sXML->breadcrumb->attributes();
					$strBreadCrumb = (string) $vAtributos['visible'];
					$strBreadCrumb = trim(strtolower($strBreadCrumb));
					if ($strBreadCrumb == 'true') {
						$this->enableBreadCrumb = true;
					}
				}

				//queryMode
				if ($sXML->queryMode)
				{
					$vAtributos = $sXML->queryMode->attributes();
					$queryMode = (string) $vAtributos['status'];
					switch (trim($queryMode))
					{
						case '0':
							$this->queryMode = 0;
							break;
						case '1':
							$this->queryMode = 1;
							break;
						case '2':
							$this->queryMode = 2;
							break;
						default:
							$this->queryMode = 2;
					}
				}//Fin if queryMode

				//DSNZone
				if ($sXML->DSNZone)
				{
					foreach ($sXML->DSNZone->dbDSN as $db)
					{
						$vAtributosDB = $db->attributes();
						$idDSN = (string) $vAtributosDB['id'];
						$dbType = (string) $vAtributosDB['sgbd'];
						$dbDriver = (string) $vAtributosDB['driver'];
						$dbHost = (string) $db->dbHost;
						$dbPort = (string) $db->dbPort;
						$dbDataBase = (string) $db->dbDatabase;
						$dbUser = (string) $db->dbUser;
						$dbPassword = (string) $db->dbPassword;
						$parse_DBType = $this->_parseDBType($dbType);
						$xmlCharset = (string) (isset($vAtributosDB['charset'])?$vAtributosDB['charset']:self::DEFAULT_DBCLIENT_ENCODING);
						$dbCharset = $xmlCharset;
						if ($dbType=='thin' || $dbType=='oracle-thin')
						{
							if (in_array($dbCharset, self::$v_unicode))
							{
								$dbCharset = 'AL32UTF8';
							}
							else
							{
								$dbCharset = 'WE8ISO8859P15';
							}

							$cadenaTNS = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=$dbHost)(PORT=$dbPort))(CONNECT_DATA=(SID=$dbDataBase)))";
							$this->vDSN[$idDSN] = array (
								'xmltype'  		=> $dbType,
								'xmlhost'  		=> $dbHost,
								'xmlport'  		=> $dbPort,
								'xmldb'    		=> $dbDataBase,
								'xmlcharset'    => $xmlCharset,
								'phptype'  		=> $parse_DBType,
								'username' 		=> $dbUser,
								'password' 		=> $dbPassword,
								'hostspec' 		=> $cadenaTNS,
								'driver'   		=> $dbDriver,
								'charset'  		=> $dbCharset
							);
						}
						elseif ($dbType=='oracle-rac' || $dbType=='oci-rac' || $dbType=='rac') //¿Cambiar por sistema de conexión TNS con nueva cadena?
						{
							if (in_array($dbCharset, self::$v_latin))
							{
								$dbCharset = 'WE8ISO8859P15';
							}
							else
							{
								$dbCharset = 'AL32UTF8';
							}
							$cadenaTNS = "(DESCRIPTION=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCP)(HOST=$dbHost)(PORT=$dbPort))(CONNECT_DATA=(SERVICE_NAME=$dbDataBase)))";
							$this->vDSN[$idDSN] = array (
								'xmltype' 		 => $dbType,
								'xmlhost' 		 => $dbHost,
								'xmlport' 		 => $dbPort,
								'xmldb'   		 => $dbDataBase,
								'xmlcharset'   	 => $xmlCharset,
								'phptype' 		 => $parse_DBType,
								'username'		 => $dbUser,
								'password'		 => $dbPassword,
								'hostspec'		 => $dbHost,//$cadena TNS y quitar service
								'port'    		 => $dbPort,
								'service'		 => $dbDataBase,//Sobraría o habría que compatibilizar la conexión en JASPER y LOGIN
								'driver'		 => $dbDriver,
								'charset'		 => $dbCharset
							);
						}
						elseif ($dbType=='pgsql') //PostgreSQL
						{
							if (in_array($dbCharset, self::$v_latin))
							{
								$dbCharset = 'LATIN9';
							}
							else
							{
								$dbCharset = 'UNICODE';
							}

							//Otros DNS (pgsql...)
							$this->vDSN[$idDSN] = array (
								'xmltype' 		=> $dbType,
								'xmlhost' 		=> $dbHost,
								'xmlport' 		=> $dbPort,
								'xmldb'   		=> $dbDataBase,
								'xmlcharset'   	=> $xmlCharset,
								'phptype'  		=> $parse_DBType,
								'username' 		=> $dbUser,
								'password'		=> $dbPassword,
								'hostspec'		=> $dbHost,
								'port'			=> $dbPort,
								'database'		=> $dbDataBase,
								'driver'   		=> $dbDriver,
								'charset'  		=> $dbCharset
							);
						}
						else //Otros...
						{
							if (in_array($dbCharset, self::$v_latin))
							{
								$dbCharset = 'latin9';
							}
							else
							{
								$dbCharset = 'utf8';
							}
							$this->vDSN[$idDSN] = array (
								'xmltype' 		=> $dbType,
								'xmlhost' 		=> $dbHost,
								'xmlport' 		=> $dbPort,
								'xmldb'   		=> $dbDataBase,
								'xmlcharset'   	=> $xmlCharset,
								'phptype'  		=> $parse_DBType,
								'username' 		=> $dbUser,
								'password' 		=> $dbPassword,
								'hostspec' 		=> $dbHost,
								'port'    		=> $dbPort,
								'database' 		=> $dbDataBase,
								'driver'  		=> $dbDriver,
								'charset' 		=> $dbCharset
							);
						}
					}//Fin foreach DB

					foreach ($sXML->DSNZone->wsDSN as $ws)
					{
						$vAtributosWS = $ws->attributes();
						$idWS = (string) $vAtributosWS['id'];

						$uriWSDL = (string) $ws->uriWSDL;
						$wsUser = (string) $ws->wsUser;
						$wsPassword = (string) $ws->wsPassword;
						$certificatePath = (string) $ws->wsCertificatePath;
						$serialCert='';
						if(!empty($certificatePath))
						{
							$vAtributosCert = $ws->wsCertificatePath->attributes();
							$serialCert = trim(strtolower($vAtributosCert['serial']));
						}

						$keyPath = (string) $ws->wsKeyPath;
						$passPhrase = (string) $ws->wsPassPhrase;
						if (empty($passPhrase))
						{
							$passPhrase = null;
						}

						$wsPAITraceIdApp = (string) $ws->wsPAITraceIdApp;
						$enablePAITrace = false;
						if(!empty($wsPAITraceIdApp))
						{
							$vAtributosPai = $ws->wsPAITraceIdApp->attributes();
							if (trim(strtolower($vAtributosPai['enablePAITrace']))=='true')
							{
								$enablePAITrace = true;
							}
						}
						$this->vDSN[$idWS] = array (
							'uriWSDL'  => 			$uriWSDL,
							'username' => 			$wsUser,
							'password' => 			$wsPassword,
							'certificatePath'=>		$certificatePath,
							'certificateSerial'=>	$serialCert,
							'keyPath' => 			$keyPath,
							'passPhrase' => 		$passPhrase,
							'wsPAITraceIdApp' =>	$wsPAITraceIdApp,
							'enablePAITrace' => 	$enablePAITrace
						);
					}//Fin foreach WS
				}//Fin if DSNZone

				// SMTP Server
				if ($sXML->smtpServer)
				{
					$this->smtpServer = array();

					$host = (string) $sXML->smtpServer->smtpHost;
					$port = (string) $sXML->smtpServer->smtpPort;
					$username = (string) $sXML->smtpServer->smtpUser;
					$password =(string) $sXML->smtpServer->smtpPassword;

					$this->smtpServer['host'] = $host;
					if($port!='') {
						$this->smtpServer['port'] = $port;
					}
					if($username!='') {
						$this->smtpServer['username'] = $username;
					}
					if($password!='') {
						$this->smtpServer['password'] = $password;
					}
				}


				//propertyZone
				if ($sXML->propertyZone)
				{
					foreach ($sXML->propertyZone->property as $property)
					{
						$vAtributosDB = $property->attributes();
						$idProperty = (string) $vAtributosDB['id'];
						$this->vProperties[$idProperty] = (string) $property;
					}
				}


				//startMsg
				 if ($sXML->startMsg)
				 {
					 $this->startMsg =  (string) $sXML->startMsg;
					 $vAtributos = $sXML->startMsg->attributes();
				 	/*
				 	// Posibilidad a futuro
					$idMessage = (string) $vAtributos['id'];
				 	$pathFileMessage = (string) $vAtributos['path'];
				 	*/
				 	$mesaggeType = (string) $vAtributos['type'];
				 	$this->startMsgType = 'info';
				 	if (trim(strtolower($mesaggeType)) == 'lock')
				 	{
				 		$this->startMsgType = 'lock';
				 	}
				 }//Fin if startMsg

				 //LangZone
				 if ($sXML->LangZone)
				 {
				 	$vAtributosLangZone = $sXML->LangZone->attributes();
				 	$this->currentLang = (string) $vAtributosLangZone['default'];
				 	$this->activeLang = ((string) $vAtributosLangZone['activate'] == 'true')?true:false;
				 	foreach ($sXML->LangZone->lang as $lang)
				 	{
				 		$vAtributosLang = $lang->attributes();
				 		$idLang = (string) $vAtributosLang['id'];
				 		$langImg = (string) $vAtributosLang['img'];
				 		$langDesc = (string) $lang;
				 		$this->vLang[$idLang]['desc'] = $langDesc;
				 		$this->vLang[$idLang]['img'] = $langImg;
				 	}//Fin foreach
				 }
				 else {
				 	$this->currentLang = 'esp';
				 	$this->vLang['esp']['desc'] = 'Español';
				 	$this->vLang['esp']['img'] = 'esp.png';
				 }//Fin if LangZone

				 //imgZone REDMINE #23227
				 if ($sXML->imgZone)
				 {
				 	foreach ($sXML->imgZone->allowedPath as $path)
				 	{
				 		$vAtributos = $path->attributes();
				 		$idAllowedPath = (string) $vAtributos['id'];
				 		$this->vImgAllowedPath[$idAllowedPath] = (string) $path;
				 	}//Fin foreach
				 }//Fin if imgZone
	    	}
	    	else //REVIEW tratamiento de Excepciones
	    	{
	    		clearstatcache();
	    		die('_loadConfigFile:: No se encuentra el fichero de configuración:'. realpath($fichero));
	    	}
		}
		catch (Exception $e)
		{
			die('_loadConfigFile::Error en carga de fichero: '.$e);
		}
	}//Fin _loadConfigFile

	/**
	 * _parseDBType: Dada una cadena con el nombre del SGBD devuelve el nombre canónico
	 *
	 * @access private
	 * @param string $sgbdType El SGBD (oracle, oci, oci8, thin, postgres, pgsql, mysql, mysqli...
	*/
	private function _parseDBType($sgbdType)
	{
		$retorno ='';
		switch (strtolower(trim($sgbdType)))
    	{
    		case 'postgres':
    		case 'pgsql':
    			$retorno = 'pgsql';
    		break;
    		case 'oci8':
    		case 'oci':
    		case 'oracle':
    		case 'thin':
    		case 'oracle-thin':
    		case 'oci-rac':
    		case 'oracle-rac':
    		case 'rac':
    			$retorno = 'oci8';
    		break;
    		case 'mysqli':
    		case 'mysql':
    			$retorno = 'mysql';
    		break;
    		case 'sqlsrv':
   			case 'mssql':
   				$retorno = 'mssql';
    		break;
   			case 'sqlite':
   			case 'sqlite3':
   				$retorno = 'sqlite';
   			break;
    		default:
    			throw new Exception('El tipo de dsn no está soportado: '.$sgbdType);
    	}
    	return($retorno);
	}

	/**
	 * setDBList_DBSource: crea una fuente de datos para una lista mediante consulta SQL
	 *
	 *  Carga la definición de una lista desplegable en el objeto de configuración para
	 * que posteriormente pueda ser utilizada en cualquier parte de la aplicación.
	 * @access public
	 * @param string $key	clave con la que se identificará la lista en la aplicación
	 * @param string $query consulta que se ejecutará al obtener la lista
	 * @param integer $cacheable Habilita el cacheo en sesión de la lista para minorar el número de accesos a BD
	 * @return integer
	*/
	public function setList_DBSource($key, $query, $cacheable=1)
	{
		$this->defList[$key]['query'] = $query;
		$this->defList[$key]['cacheable'] = $cacheable;
		return 0;
	}

	/**
	 * setClassList_ClassSource: crea una fuente de datos para una lista con una clase
	 *
	 *  Asocia una clase a la fuente de datos. Atencion: La clase tiene que implementar la interfaz gvHidraList_Source
	 *
	 * @access public
	 * @param string $key	clave con la que se identificará la lista en la aplicación
	 * @param string $class clase que se instanciará para obtener la lista
	 * @param integer $cacheable Habilita el cacheo en sesión de la lista para minorar el número de accesos a BD
	 * @return integer
	*/
	public function setList_ClassSource($key, $class, $cacheable=1)
	{
		//Comprobamos que la clase existe
		if(!class_exists($class)){
			IgepDebug::setDebug(ERROR,"Se ha intentado crear una ClassSource para una List con una clase que no existe. Compruebe que la clase $class esta incluida en el fichero include de la aplicacion");
			return -1;
		}
		//Comprobamos que la clase implementa la interfaz
		if(!in_array('gvHidraList_Source',class_implements($class))){

			IgepDebug::setDebug(ERROR,"La clase $class no puede ser fuente de una lista ya que no implementa la interfaz gvHidraListSource");
			return -1;
		}

		$this->defList[$key]['class'] = $class;
		$this->defList[$key]['cacheable'] = $cacheable;
		return 0;
	}


	/**
	 * getDefList: devuelve la definición de una lista desplegable
	 *
	 *  Devuelve la definición de una lista desplegable. Concretamente devuelve la sentencia SELECT con
	 * la que se obtienen los resultados deseados.
	 * @access public
	 * @param string $key	clave con la que se identifica la lista en la aplicación
	 * @return integer
	*/
	function getDefList($key)
	{
		if(isset($this->defList[$key]))
			return $this->defList[$key];
		return -1;
	}


	/**
	 * getListKeys: devuelve las claves de las listas desplegables
	 *
	 * @access public
	 * @return array
	*/
	function getListKeys()
	{
		return array_keys($this->defList);
	}

	/**
	 * setCacheList: método que fija el valor del contenido cacheado para la lista
	 *
	 * @access public
	 * @param key identificador de la lista
	 * @param cache resultado de la consulta
	 */
	public function setCacheList($key, $cache)
	{
		if(isset($this->defList[$key])) {
			if($this->defList[$key]['cacheable']!=0) {
				$this->defList[$key]['cache'] = $cache;
			}
		}
	}

	/**
	 * getCacheList: método que devuelve el valor del contenido cacheado para la lista
	 *
	 * @access public
	 * @param key identificador de la lista
	 * @return array
	 */
	public function getCacheList($key)
	{
		if (isset($this->defList[$key]['cache']))
		{
			return $this->defList[$key]['cache'];
		}
		return null;
	}

	/**
	 * clearCacheList: método que borra la cache de las listas
	 *
	 * @access public
	 * @param key identificador de la lista
	 * @return integer
	 */
	public function clearCacheList($key = null)
	{
		if(empty($key))
		{
			$lists = $this->getListKeys();
			foreach($lists  as $list)
			{
				if(isset($this->defList[$list]))
				{
					if($this->defList[$list]['cacheable']!=2) {
						unset($this->defList[$list]['cache']);
					}
				}
			}
		}
		else
		{
			if($this->defList[$list]['cacheable']!=2) {
				unset($this->defList[$key]['cache']);
			}
		}

		return 0;
	}

	/**
	 * Crea una fuente de datos para WindowSelection con origen en una consulta SQL.
	 * @access public
	 * @param string $key	Clave con la que se identificará la VS en la aplicación
	 * @param string $query Expresión (consulta) con la que obtendremos el resultado
	 * @param array $fields Opcional. Campos de busqueda adicionales a los incluidos en la consulta
	 * @return void
	*/
	public function setSelectionWindow_DBSource($key, $query, $fields=null)
	{
		$this->defVS[$key]['consulta'] = $query;
		if(!empty($fields))
			$this->defVS[$key]['camposBusqueda'] = $fields;
		return 0;
	}

	/**
	 * Crea una fuente de datos para una búsqueda Live Search con origen en una consulta SQL.
	 * @access public
	 * @param string $key	Clave con la que se identificará la VS en la aplicación
	 * @param string $query Expresión (consulta) con la que obtendremos el resultado
	 * @param array $fields Opcional. Campos de busqueda adicionales a los incluidos en la consulta
	 * @return void
	 *
	 * REDMINE: Live Search Ajax #22982
	 */
	//public function setLiveSearch_DBSource($key, $query, $headers, $fields=null, $pattern=null, $template=null)
	public function setLiveSearch_DBSource($key, $query, $fields=null, $headers=null)
	{
	    /*$conf = [
	        'headers'     => array('NRP', 'Nombre','Apellido 1','Apellido 2', 'codper'),
	        'fields'      => array("NOMB","APE1","APE2"),
	        'pattern'     => '*q',
	        'fieldMatch'  => 'NOMB'
	    ];*/
	    $this->defLS[$key]['consulta'] = $query;

	    if(!empty($fields)) {
	        $this->defLS[$key]['camposBusqueda'] = $fields;
	    }

	    if(!empty($headers)) {
	        $this->defLS[$key]['headers'] = $headers;
	    }

	    /*$this->defLS[$key]['patron'] = '*q*';
	    if(!empty($pattern)) {
	        $this->defLS[$key]['patron'] = $pattern;
	    }

	    $this->defLS[$key]['template'] = 'default.php';
	    if(!empty($template)) {
	        $this->defLS[$key]['template'] = $template;
	    }*/
	    return 0;
	}

	/**
	 * Crea una fuente de datos para WindowSelection con origen en una clase.
	 *
	 * Atencion: La clase tiene que implementar la interfaz gvHidraSelectionWindow_Source
	 *
	 * @access public
	 * @param string $key	Clave con la que se identificará la VS en la aplicación
	 * @param string $class Indica la clase que sera la definición de la VS
	 * @return void
	*/
	public function setSelectionWindow_ClassSource($key, $class)
	{
		//Comprobamos que la clase existe
		if(!class_exists($class)){
			IgepDebug::setDebug(ERROR,"Se ha intentado crear una ClassSource para una WindowSelection con una clase que no existe. Compruebe que la clase $class esta incluida en el fichero include de la aplicacion");
			return -1;
		}
		//Comprobamos que la clase implementa la interfaz
		if(!in_array('gvHidraSelectionWindow_Source',class_implements($class))){

			IgepDebug::setDebug(ERROR,"La clase $class no puede ser fuente de una SelectionWindow ya que no implementa la interfaz gvHidraSelectionWindow_Source");
			return -1;
		}

		$this->defVS[$key]['class'] = $class;
		return 0;
	}


	/**
	 * getChangelogFile()
	 * Devuelve la directiva de configuración changelogFile
	 * getChangelogFile
	 *
	 * @return void
	 */
	public static function getChangelogFile()
	{
		if(empty(self::$_instance))
		{
			$ficheros = array('./gvHidraConfig.inc.xml');
			$externalConfig = self::getExtConfigFile();
			if(!empty($externalConfig))
			{
				$ficheros = array($externalConfig);
			}

			foreach ($ficheros as $fichero)
			{
				if (file_exists($fichero))
				{
					$sXML = simplexml_load_file($fichero);
					if(!empty($sXML->changelogFile))
					{
						$changelogFile = (string) $sXML->changelogFile;
					}
				}
				else
				{
					throw new Exception('getChangelogFile: no existe el fichero '.$fichero);
				}
			}
			if (!empty($changelogFile))
			{
				return($changelogFile);
			}
			throw new Exception('getChangelogFile: no está definido el codigo de la aplicación');
		}
		return self::$_instance->changelogFile;
	}


	/**
	 * getDefVS:
	 *
	 * Devuelve la definición de una ventana de seleccion.
	 * @access public
	 * @param string $key	clave con la que se identifica la lista en la aplicación
	 * @return array
	*/
	function getDefVS($key)
	{
		if(isset($this->defVS[$key]))
			return $this->defVS[$key];
		return -1;
	}

	/**
	 * getVSKeys: devuelve las claves de las ventanas de seleccion
	 *
	 * @access public
	 * @return array
	 */
	function getVSKeys()
	{
	    return array_keys($this->defVS);
	}

	/**
	 * getDefLS:
	 *
	 * Devuelve la definición de una ventana de seleccion.
	 * @access public
	 * @param string $key	clave con la que se identifica la lista en la aplicación
	 * @return array
	 */
	function getDefLS($key)
	{
	    if(isset($this->defLS[$key]))
	        return $this->defLS[$key];
	        return -1;
	}

	// REDMINE: Live Search Ajax #22982
	/**
	 * getLSKeys: devuelve las claves de las live search
	 *
	 * @access public
	 * @return array
	*/
	function getLSKeys()
	{
		return array_keys($this->defLS);
	}

	/**
	 * setDSN: almacena un vector de conexion a una BD
	 *
	 *  Guarda en la configuración una conexión a la BD que posteriormente
	 * se utilizará en la aplicacion.
	 * @access public
	 * @param string $key	clave con la que se identificará el array de conexion
	 * @param string $vdsn	array de conexion basado en la estructura PEAR
	 * @return void
	*/
	function setDSN($key, $vdsn)
	{
		$this->vDSN[$key] = $vdsn;
	}

	/**
	 * getDSN: devuelve el array de conexion a una fuente de datos (SGBD o WS)
	 *
	 * Dada un ID devuelve el array de conexion correspondiente a una fuente de
	 * datos. Dicha fuente puede ser una conexión a un SGBD o bien a un recurso
	 * WService
	 * @access public
	 * @param string $key	clave con la que se identifica el array de conexion
	 * @return array
	*/
	function getDSN($key)
	{
		if(isset($this->vDSN[$key]))
			return $this->vDSN[$key];
		return null;
	}

	/**
	 * getLanguage: Devuelve el identificador del lenguaje activo
	 *
	 *
	 * @access public
	 * @return string
	 */
	public function getLanguage()
	{
		return $this->currentLang;
	}

	/**
	 * getLanguages: Devuelve el array de idiomas disponibles
	 *
	 *
	 * @access public
	 * @return array
	 */
	public function getLanguages()
	{
		return $this->vLang;
	}

	/**
	 * setLanguage: Cambia el idioma activo. Se debe seleccionar un idioma entre los disponibles en la configuración
	 *
	 * @access public
	 * @param string $lang
	 * @return void
	 */
	public function setLanguage($lang)
	{
		if( !is_array($this->vLang) || !array_key_exists($lang, $this->vLang))
			return -1;
		$this->currentLang = $lang;
	}

	/**
	 * getAllowedPath: Devuelve el array de path permitidos
	 *
	 * @access public
	 * @return array
	 */
	public function getAllowedPath()
	{
		return $this->vImgAllowedPath;
	}

	/**
	 * getSMTPServer: Devuelve el stmp del servidor
	 *
	 * @access public
	 * @return string
	 */
	public function getSMTPServer()
	{
		return $this->smtpServer;
	}

	/**
	 * getDSNLog: Devuelve el dsn usado para el Log
	 *
	 * @access public
	 * @return array
	*/
	function getDSNLog()
	{
		return $this->vDSN[$this->logDSN];
	}

	/**
	 * getSecurityLog: Devuelve el parametro de seguridad del Log
	 *
	 * @access public
	 * @return array
	 */
	public function getSecurityLog()
	{
		return $this->logSecurity;
	}

	/**
	* getNumericSeparatorsFW: devuelve el formato numérico que utilizará en FW.
	* 	Este formato coincidirá con el formato PHP
	* @acces public
	* @return array
	*/
	static function getNumericSeparatorsFW(){
  		return array('DECIMAL'=>'.','GROUP'=>'');
	}

	/**
	* getNumericSeparatorsUser: devuelve el formato numérico que utilizará el usuario en pantalla.
	*
	* @acces public
	* @return array
	*/
	static function getNumericSeparatorsUser(){
		return array('DECIMAL'=>',','GROUP'=>'.');
	}

	/**
	* getDateMaskFW: devuelve el formato de fechas que utilizará en FW.
	* 	Este formato coincidirá con el formato PHP
	* @acces public
	* @return string
	*/
	static function getDateMaskFW(){
  		return 'Y-n-j';
	}

	/**
	* getDateMaskUser: devuelve la mascara de representacion de fechas de pantalla
	*
	* @acces public
	* @return string
	*/
	static function getDateMaskUser(){
		return 'd/m/Y';
	}

	/**
	* getTimeMask: devuelve la mascara de hora usada en todos los sitios (bd, User, FW)
	* Si se cambia, ha de ser valido para todos los sgbd soportados
	*
	* @acces public
	* @return string
	*/
	static function getTimeMask()
	{
		return 'H:i:s';
	}

	static function getTransformErrors()
	{
		return self::$transformErrors;
	}

	static function setTransformErrors($lis)
	{
		self::$transformErrors = $lis;
		if (!empty($lis))
			IgepDebug::setDebug(DEBUG_IGEP,'La transformación ha detectado errores en la entrada del usuario: '.var_export($lis,true));
	}

	/**
	* getStringFromXML: metodo para obtener el valor de un atributo en un fichero XML.
	*
	* @acces private
	* @return string
	*/
	static private function getStringFromXML($fichero, $atributo)
	{
		$sXML = simplexml_load_file($fichero);
		$value = (string) $sXML->$atributo;
		unset($sXML);//Liberamos el recurso
		return($value);
	}

}//Fin ConfigFramework
?>