<?php
/**
 * @package igep
 */

/**
* Definición del nombre del fichero actual
*/
define("NOMBRE_FICHERO","IgepConexion.php");


/**
 * IgepConexion es una clase que corresponde a un manejador de una conexion a una 
 * bases de datos determinada. Controla las operaciones correspondientes a la conexión
 * y a las transacciones.
 * 
 * Consta de las siguientes propiedades:
 * <ul>
 * <li><b>$obj_conexion</b> - El objeto de conexión con el que trabaja.</li>
 * <li><b>$obj_errorConexion</b> - Referencia al objeto de error global</li>
 * </ul>
 *
 * @version	$Id: IgepConexion.php,v 1.28 2006-06-05 11:51:11 afelixf Exp $
 * @author David: <pascual_dav@gva.es> 
 * @author Keka: <bermejo_mjo@gva.es>
 * @author Vero: <navarro_ver@gva.es>
 * @author Raquel: <borjabad_raq@gva.es> 
 * @author Toni: <felix_ant@gva.es>
 * @package	igep
 */


 class IgepConexion {
 	
 	/**
     * objeto conexion
     *
     * @var object obj_conexion
     */	     
	var $obj_conexion;
	
	 /**
     * variable de error
     *
     * @var object obj_errorConexion
     */		
	var $obj_errorConexion;

	 /**
     * variable de que contiene la descripción del dsn al que se conecta
     *
     * @var array v_dsn
     */		
	var $v_dsn;

	/**
	 * Constructor. Recibe como parámetro un array con la definición
	 * del dsn.
	 *
	 * @access	public
	 * @param	array	$dsn
	 */	
	function IgepConexion($dsn) {
		//Cogemos la referencia de la variable de error global
		global $g_error;
		$this->obj_errorConexion = & $g_error;
		//Realizamos la conexión
		$this->v_dsn = $dsn;		    
		$this->obj_conexion = $this->conectar();		
	}
	 
	//destructor
	function _IgepConexion() {
		$this->desconectar();
	}
	
	/**
	 * Realiza la conexión a la base de datos especificada
	 *
	 * @access	public
	 * @return	object
	 */	
	function conectar(){						
		include_once('igep/include/igep_bd/IgepDB.php');
		//$this->v_dsn = 
		IgepDB::preConexion($this->v_dsn);
		$res = DB::connect($this->v_dsn);
		if (DB::isError($res))   {
			$this->obj_errorConexion->setError("IGEP-6",NOMBRE_FICHERO,"conectar",$res);					
		} else IgepDB::postConexion($this->v_dsn,$res);
    	return $res;
	}// Fin de conectar

	/**
	 * Realiza la desconexión a la base de datos a la que actualmente
	 * se está conectado.
	 *
	 * @access	public
	 */	
	function desconectar(){	
		if(isset($this->obj_conexion)) {
			$res = DB::disconnect($this->obj_conexion);		
			if (DB::isError($res)) 
    				$this->obj_errorConexion->setError("IGEP-7",NOMBRE_FICHERO,"desconectar",$res);
		}    	
	}// Fin de desconectar

	/**
	 * Devuelve el objeto conexión al que se está conectado.
	 *
	 * @access	public
	 * @return	object
	 */		
	function getConexion(){
		return $this->obj_conexion;
	}//Fin de getConexion

	/**
	 * Devuelve el dsn de la conexión.
	 *
	 * @access	public
	 * @return	array
	 */		
	function getDsn(){
		return $this->v_dsn;
	}//Fin de getDsn

	/**
	 * Empieza una transacción (BEGIN) en la conexión a la que 
	 * está apuntando.
	 *
	 * @access	public
	 */		
	function empezarTransaccion()
	{
    //Debug:Indicamos que ejecutamos la consulta
    IgepDebug::setDebug(DEBUG_IGEP,'Empezamos transacción.');

		$res = IgepDB::empezarTransaccion($this->v_dsn,$this->obj_conexion);
		if (DB::isError($res)) 
    			$this->obj_errorConexion->setError("IGEP-8",NOMBRE_FICHERO,"empezarTransaccion",$res);    	
	}//Fin de empezarTransaccion

	/**
	 * Finaliza una transacción (COMMIT o ROLLBACK) en la conexión a la que 
	 * está apuntando. Recibe un parámetro que indica si el procesado de las
	 * diferentes operaciones que se han realizado ha concluido satisfactoriamente
	 * o no. Dependiendo de ello se realizará el COMMIT o el ROLLBACK. Dicho 
	 * parámetro es $error
	 * <ul>
	 * <li>0. No ha habido ningún error en el proceso. Realizamos COMMIT</li>
	 * <li>1. Ha habido algún error durante el proceso. Realizamos ROLLBACK</li>
	 * </ul>
	 *
	 * @access	public
	 * @param	integer	$error
	 */		
	function acabarTransaccion($error){
    //Debug:Indicamos que ejecutamos la consulta
    IgepDebug::setDebug(DEBUG_IGEP,'Acabamos transacción con '.$error);
    		
		$res = IgepDB::acabarTransaccion($this->v_dsn,$this->obj_conexion,$error);
		if (DB::isError($res))
    			$this->obj_errorConexion->setError("IGEP-9",NOMBRE_FICHERO,"acabarTransaccion",$res);    	
	}//Fin de acabarTransaccion
	
	/**
	* Método  encargado de construir las WHERE de las consultas. 
	* @access	private
	*/
	function construirWhere($v_datos,$str_where){		
		//Esta función construye una WHERE igualando los valores con los nombres de los campos.
		if (isset($v_datos)){	
			if($str_where!='')
				$inicio_condicion=' OR (';
			else
				$inicio_condicion=' (';							
			$str_condicion='';
			foreach($v_datos as $prop => $val) {					
				if ($str_condicion!='') { 
					$str_condicion.=' AND '; 
				}			
				$str_condicion.=$prop;
				if (gettype($val)=='string') {
					if($val!='') 
						$str_condicion.="='".$val."'";
					else
						$str_condicion.=' is null';
				}					
		  		else {
		  		 	if($val!='')
		  				$str_condicion.='='.$val;
		  			else
						$str_condicion.=' is null';		  		
		  		}					
			}//FIN foreach
			if(trim($str_condicion)!='')
				$str_where.=$inicio_condicion.$str_condicion.')';											
		}
		return $str_where;		
	} //Fin de construirWhere
	
	/**
	* Método  encargado de construir las WHERE de las consultas incluyendo las condiciones de busqueda que ha seleccionado el programador a partir del parámetro gint_tipoConsulta 
	* @access	private
	*/
	function construirWhereConLike($v_datos,$str_where,$tipoConsulta){
		/*Dependiendo del valor de la variable global gint_tipoConsulta realiza una construcción de la Where u otra.Los tipos 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.      		
		*/
		//Accedemos a la varible global que nos dice que tipo de Consulta debemos realizar para toda la aplicación.
		if($tipoConsulta==0)		
			return  $this->construirWhere($v_datos,$str_where);
		else
			//Construimos la Where
			if (isset($v_datos)){	
				if($str_where!='')				
					$inicio_condicion =' OR ('; 
				else
					$inicio_condicion =' (';
				$str_condicion='';
				foreach($v_datos as $prop => $val){
					if($val!=''){					
						if ($str_condicion!=''){ 
							$str_condicion.=' AND '; 
						}			
						$str_condicion.=$prop;
						if($tipoConsulta==2){
							//Son 3 iguales porque si colocamos 2 no distinguimos entre algo que esté en la posición 0 y el false								
							if((strpos($val,'%')===false) and (strpos($val,'_')===false)){
								if (gettype($val)=='string') 					 
										$str_condicion.="='".$val."'";
								else
										$str_condicion.='='.$val;																	
							}								
							else {
									$str_condicion.=" LIKE '".$val."'";
							}									
						}//Fin tipoConsulta == 2
						else {
							$str_condicion.=" LIKE '%".$val."%'";
						}
					}
				}//FIN foreach
				if(trim($str_condicion)!='')
					$str_where.=$inicio_condicion.$str_condicion.')';				
			}				
		return $str_where;
	}//Fin de construirWhereConLike
	
	
	/**
	 * Método encargado de, dadas una serie de cadenas, componerlas para crear una única
	 * cadena para la where de una SQL.
	 * @acces	private
	 * @param array $v_cadenas Array que contiene las diferentes cadenas que componen la WHERE  
	 * @return	string
	 */
	function combinarWhere($v_cadenas){
		$str_where = '';
		foreach($v_cadenas as $cadena){
			if(trim($cadena)!=''){
				if ($str_where!='')
					$str_where.= ') AND ';
				$str_where.='('.$cadena;
			}
		}
		if($str_where!='')
			$str_where=' WHERE '.$str_where.')';
		return $str_where;
	}
	
	/**
	* Método encargado de construir el limit para las consultas 
	* @access	private
	*/	
	function construirLimite(& $str_where,$int_limiteConsulta=100){    
    if(is_int($int_limiteConsulta)){
      $limite = IgepDB::obtenerLimit($str_where, $this->v_dsn, $int_limiteConsulta);
    }     
		return $limite;
	}//Fin de construirLimite
	
	
  /**
  * Esta función se encarga de cambiar los datos que vienen de la Base de datos, transformándolos al formato de presentación adecuado.
  * P.E.: Cambia el formato de los números decimales colocando como separador decimal la coma.
  *
  * @access	private
  * @param	$res	Es el contenido del DBResult que se recibe por referencia para poder cambiarlo.
  * @param	$camposDecimalesHijo	En el caso de recargar, tenemos que pasarle los campos decimales del hijo.
  * @return	mixed
  */
  function presentaDatos(& $res,$camposExaminados){ 	 	 	 	 	
   	//Si $camposExaminados tiene elementos 	
   	if(isset($camposExaminados)){
        $carbd = IgepDB::caracteresNumericos($this->getDsn());
        $carconf = ConfIgep::caracteresNumericos();
  	  if ($carbd['DECIMAL'] != $carconf['DECIMAL']) {
   	    //Recorremos todo el $res y por cada fila realizamos la transformación.
   		foreach($res as $indice => $fila){
   		  foreach($camposExaminados as $campo){ 					
   			$posUltPunto = strrpos($fila[$campo],$carbd['DECIMAL']); 					
   			if($posUltPunto>0)			
   			  $res[$indice][$campo] = substr_replace($fila[$campo],$carconf['DECIMAL'],$posUltPunto,1); 					  				 
   		  }//Fin de foeach de camposExaminados
   		}//Fin de foreach $res
   	  }// Fin de if si hay que convertir los datos
   	}//Fin de if si hay decimales 	 	 
  }//Fin de presentaDatos
	

  /**
   * Dada una una consulta realiza la SELECT correspondiente.
   *
   * @access  public
   * @param string  $str_select
   * @return  object
   */         
  function consultar($str_select){
    //Debug:Indicamos que ejecutamos la consulta
    IgepDebug::setDebug(DEBUG_IGEP,'IgepConexion: Ejecutamos consulta: '.$str_select);
    
    $res = $this->obj_conexion->getAll($str_select,null,DB_FETCHMODE_ASSOC);    
    if (DB::isError($res)){                 
      $this->obj_errorConexion->setError("IGEP-5",NOMBRE_FICHERO,"consultar",$res,$str_select);
      return -1;
    }
    return $res;    
  }

  /**
   * Dada una una consulta realiza la SELECT correspondiente.
   *
   * @access  public
   * @param string  $str_select
   * @return  object
   */         
  function operar($str_operar){
    //Debug:Indicamos que ejecutamos la operacion
    IgepDebug::setDebug(DEBUG_IGEP,'IgepConexion: Ejecutamos operación: '.$str_operar);
                   
    $res = $this->obj_conexion->simpleQuery($str_operar);
    if (DB::isError($res)){                  
      $this->obj_errorConexion->setError("IGEP-11",NOMBRE_FICHERO,"operar",$res,$str_operar);
      return -1;
    }                                 
    return $res;    
  }
  
  /**
   * Este método prepara los datos que se van a utilizar en una operación de la BD.
   * Típicamente las comillas simples y las contrabarras en los INSERT, UPDATE o DELETE
   *
   * @access  public
   * @param string  $a_parametros
   * @return  none
   */         
  function prepararOperacion(& $a_parametros){
    if(is_array($a_parametros)){
      foreach($a_parametros as $indice => $parametro){
        $val = str_replace("'","''",$parametro);
        $val = str_replace("\\","\\\\",$val);
        $a_parametros[$indice]=$val;        
      }
    }    
    else {
      $val = str_replace("'","''",$a_parametros);
      $val = str_replace("\\","\\\\",$val);
      $a_parametros=$val;      
    }    
  }

  /**
  * Este método devuelve el valor de una secuencia programada en la base de datos 
  * para la conexion actual 
  *
  * @param  nombreSecuencia string  nombre de la secuencia en la BD
  * @return integer 
  */
  function calcularSecuenciaBD($nombreSecuencia){
    $sql = IgepDB::obtenerSecuenciaBD($this->getDsn(),$nombreSecuencia);
    IgepDebug::setDebug(DEBUG_IGEP,'IgepConexion: Calculamos secuencia BD: '.$sql);
    $res = $this->obj_conexion->getAll($sql,null,DB_FETCHMODE_ASSOC);
    if (DB::isError($res)){                  
      $this->obj_errorConexion->setError('IGEP-12',NOMBRE_FICHERO,"calcularSecuenciaBD",$res);
      return -1;
    }
    else
      return $res[0]['nextval'];    
  }
  
  /**
  * Este método calcula una secuencia compuesta por varios campos de la misma tabla.
  *
  * @param tabla string nombre de la tabla de la BD
  * @param campoSecuencia  string campo del que se quiere obtener la secuencia
  * @param camposDependientes array contiene el nombre de los campos de los cuales va a depender la secuencia y sus valores. Estructura [nombreBD] = valor 
  * @param valorInicial  integer Fija el valor inicial que devuelve calcularSecuencia en el caso de que no exístan tuplas en la tabla el valor por defecto es 1
  * @return integer
  */
  function calcularSecuencia($tabla,$campoSecuencia,$camposDependientes, $valorInicial=1){
    $i=0;
    foreach($camposDependientes as $campo => $valor){
      if($where!='')
        $where.=' AND ';
      else
        $where = 'WHERE ';
      $where.=$campo."='".$valor."' ";
      $i++;
    }
    $sql = "SELECT max($campoSecuencia) as \"secuencia\" FROM $tabla $where";
    IgepDebug::setDebug(DEBUG_IGEP,'IgepConexion: Calculamos secuencia: '.$sql);   
    $res = $this->obj_conexion->getAll($sql,null,DB_FETCHMODE_ASSOC);
    if(DB::isError($res)) {
      $this->obj_errorConexion->setError('IGEP-12',NOMBRE_FICHERO,'calcularSecuencia',$res);
      return -1;
    }
    else {
      if (($res[0]['secuencia']=='')||($res[0]['secuencia']==null)||(!isset($res[0]['secuencia'])))
        return $valorInicial;
      else 
        return ($res[0]['secuencia'] +1);
    }
  }//Fin de funcion calcularSecuencia

}//Fin clase IgepConexion
?>