Location: PHPKode > scripts > Persistencia > persistencia/class.Objetc.php
<?php
/**
 * Esta es la clase padre de los entitys de tal manera que todo hereden de este
 *
 * @author      Juan Duarte
 * @copyright   Jukslack Inc.
 * @license     GNU LGPL
 * @see         Something
 * @link        http://www.example.com      Description of site
 * @remarks     Something people using the class might want to know.
 * 
 */
class Object{
	/**
	 * Este atributo indica la bd a la que pertenece la entidad
	 *
	 * @var String
	 */
	private $bd;
	/**
	 * Este atributo indica la cantidad de llaves primarias
	 * Nota: las llaves primarias deben estar declaradas en los primeros items.
	 *
	 * @var int
	 */
	private $pk;
	/**
	 * Este atributo indica el nombre de la clase a la que pertenece el objeto.
	 * especialmente es usado en la encapsulación de objetos.
	 *
	 * @var unknown_type
	 */
	private $nombreclase;

	private $rs;

	/**
	 * Esta función es para la asignación del atributo bd
	 *
	 * @param String $bd
	 */

	protected $retorno;

	public function setBd(BdMysql &$bd){
		$this->bd=$bd;
	}
	/**
	 * Esta función es para la asignación del atributo nombreclase
	 *
	 * @param String $nombreclase
	 */
	public function setNombreclase($nombreclase){
		$this->nombreclase=$nombreclase;
	}
	/**
	 * Esta función es para la asignación del atributo pk
	 *
	 * @param int $pk
	 */
	public function setPk($pk){
		$this->pk=$pk;
	}
	/**
	 * Esta función es para la obtención del atributo bd
	 *
	 * @return String
	 */
	public function getBd(){
		return $this->bd;
	}
	/**
	 * Esta función es para la obtención del atributo nombreclase
	 *
	 * @return nombreclase
	 */
	public function getNombreclase(){
		return $this->nombreclase;
	}
	/**
	 * Esta función es para la obtención del atributo pk
	 *
	 * @return pk
	 */
	public function getPk(){
		return $this->pk;
	}
	/**
	 * Esta función es la que permite la persistencia de la entidad
	 *
	 * @param  bool $auto
	 * @return bool
	 */
	public function save($auto=false){
		$class = new ReflectionClass($this->nombreclase);
		$sql1 = "INSERT INTO ";
		$sql2 = " VALUES ( ";
		$aux="";
		$primero = true;
		$sn = true;

		$pk=$this->pk;
		$sql1 .= strtolower($this->nombreclase)." ( ";

		$a=$class->getProperties();
		$i=0;
		foreach ($a as $clave => $valor){
			if($valor->isPrivate()){
				/* valido que no vallan vacias las llaves primarias o foraneas */
				if($i<($this->pk)||is_object($this->{$valor->getName()})){
					$sn = $this->validaCampo($this,$valor->getName());
					if(!$auto){
						if (!$sn)
						return false;
					}
				}

				if($this->validaCampo($this,$valor->getName())){
					$this->retorno=null;
					$this->getNombreValor($this,$valor->getName());

					foreach ($this->retorno AS $key => $value){
						if(!$primero){
							$sql1 .= ", " ;
							$sql2 .= ", ";
						}
						else
						$primero = false;

						/* agrego el contenido */
						/*Verifico si el campo se llama clave para encriptarlo*/
						if($key=="clave")
						$value="md5(".$value.")";
						$sql2 .= $value;
						/* agrego la cabecera */
						$sql1 .= $key;
					}
				}
				$i++;
			}
		}

		$sql1 .= " )";
		$sql2 .= " )";
		//echo $sql1.$sql2;
		$this->bd->query($sql1.$sql2);
		$var=$this->bd->numRows();
		$this->bd->inicializar();
		if($var>0)
		return true;
		return false;
	}
	/**
	 * Función que permite la actualización de una entidad
	 *
	 * @param array $pks
	 * @return bool
	 */
	public function update($pks){
		$class = new ReflectionClass($this->nombreclase);
		$pk = 0;
		$valors = null;
		$nombre = null;
		$sql = "";
		$tabla = "";
		$sql_fin = " WHERE ";
		$sw = false;
		$f=$class->getProperties();

		//Verifico que vengan todos los valores de las primary keys
		if (sizeof($pks)==0||sizeof($pks)<$this->getPk())
		return false;

		//Asigno los valores de las primary keys
		for ($i = 0; $i < sizeof($pks) && $i < $this->getPk(); $i++) {
			if ($i > 0)
			$sql_fin .= " AND ";
			if (is_int($this->{$f[$i]->getName()}))
			$valor=$pks[$i];
			else
			$valor = "'".$pks[$i]."'";

			$sql_fin .= $f[$i]->getName() . "=" . $valor;
		}

		$sql = "UPDATE ".strtolower($this->getNombreclase())." SET ";
		//Recorro todos los atributos para los sets del update
		foreach ($f as $clave => $valor ){
			if($valor->isPrivate()){
				//echo $valor->getName()."<br/>";
				if($this->validaCampo($this,$valor->getName())){
					$this->retorno=null;
					$this->getNombreValor($this,$valor->getName());

					foreach ($this->retorno AS $key => $value){
						if ($sw == true)
						$sql .= ", ";
						else
						$sw = true;

						/*Verifico si el campo se llama clave para encriptarlo*/
						if($key=="clave")
						$value="md5(".$value.")";

						$sql .= $key . "=" . $value;
					}
				}
			}
		}
		$sql.=$sql_fin;
		//echo $sql;
		$this->bd->query($sql);
		$var=$this->bd->numRows();
		$this->bd->inicializar();
		if ($var > 0)
		return true;
		return false;
	}
	/**
	 * Función que permite la eliminación de una entidad.
	 *
	 * @return bool
	 */
	public function  delete(){
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();
		$valors = null;
		$nombre = null;

		$sql = "DELETE FROM ".strtolower($this->getNombreclase())." WHERE ";
		$i=0;
		for ($i=0;$i<$this->getPk();$i++){
			if($f[$i]->isPrivate()){
				if ($i > 0)
				$sql .= " AND ";

				if($this->validaCampo($this,$f[$i]->getName())){
					$this->retorno=null;
					$this->getNombreValor($this,$f[$i]->getName());
					foreach ($this->retorno AS $key => $value)
					$sql .= $key . "=" . $value;
				}
				else
				return false;
			}
		}

		//echo $sql;
		$this->bd->query($sql);
		$var=$this->bd->numRows();
		$this->bd->inicializar();
		if ($var > 0)
		return true;
		return false;
	}
	/**
	 * Metodo que verifica si existe el objeto
	 *
	 * @return bool
	 */
	public function exist(){
		$sql = "SELECT * FROM ".strtolower($this->getNombreclase())." WHERE ";
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();

		for ($i = 0; $i < $this->getPk(); $i++) {
			if ($f[$i]->isPrivate()) {
				if ($i != 0)
				$sql.= ", ";
				if($this->validaCampo($this,$f[$i]->getName())){
					$this->retorno=null;
					$this->getNombreValor($this,$f[$i]->getName());
					foreach ($this->retorno AS $key => $value)
					$sql .= $key . "=" . $value;
				}
				else
				return false;
			}
		}
		//echo $sql;
		$this->bd->query($sql);
		$var=$this->bd->numRows();
		$this->bd->inicializar();
		if($var > 0)
		return true;
		return false;
	}
	/**
	 * Función que realiza una consulta a partir de lo valores que contenga el objeto
	 * Si este contiene valores realiza consulta y retorna un array con los valores de c/u de los atributos
	 * @return unknown
	 */
	public function query(){
		$sql = "SELECT * FROM ".strtolower($this->getNombreclase())." WHERE ";
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();
		$seguro=false;

		for ($i = 0; $i < sizeof($f); $i++) {
			if ($f[$i]->isPrivate()) {
				if($this->validaCampo($this,$f[$i]->getName())){
					if ($seguro){
						$sql.= " AND ";
						$seguro=false;
					}
					$seguro=true;
					$this->retorno=null;
					$this->getNombreValor($this,$f[$i]->getName());
					foreach ($this->retorno AS $key => $value){
						/*Verifico si el campo se llama clave para encriptarlo*/
						if($key=="clave")
						$value=" md5(".$value.") ";

						$sql .= $key . "=" . $value;
					}
				}
			}
		}

		$this->rs = $this->bd->query($sql);
		$var=$this->bd->numRows();
		$aux=$this->bd->getContentAll();
		$this->bd->inicializar();
		if($var>0)
		return $aux;
		return false;
	}
	public function cargaObjeto(){
		$sql = "SELECT * FROM ".strtolower($this->getNombreclase())." WHERE ";
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();

		for ($i = 0; $i < $this->getPk(); $i++) {
			if ($f[$i]->isPrivate()) {
				if ($i != 0)
				$sql.= ", ";
				if($this->validaCampo($this,$f[$i]->getName())){
					$this->retorno=null;
					$this->getNombreValor($this,$f[$i]->getName());
					foreach ($this->retorno AS $key => $value)
					$sql .= $key . "=" . $value;
				}
				else
				return false;
			}
		}
		$this->bd->query($sql);
		$r=$this->bd->getContentAll();
		$this->bd->inicializar();
		if(sizeof($r) > 0){
			$this->cargaRecursiva($this,$r[0],true);
			return true;
		}
		return false;
	}
	/**
	 * Metodo que carga un objeto con las variables que vienen por get y post
	 *
	 * @param Array $param
	 */
	public function cargaRequest($param){
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();

		for($i=0;$i<sizeof($f);$i++){
			if($f[$i]->isPrivate()){
				if(!is_object($this->{$f[$i]->getName()})){
					$aux=$param[strtolower($f[$i]->getName())];
					if($aux<>null && strlen(trim($aux))>0)
					$this->{$f[$i]->getName()}=$aux;
				}
				else
				$this->{$f[$i]->getName()}->cargaRequest($param);
			}
		}
	}

	public function muestraObjeto(){
		echo "<br/>".$this->nombreclase;
		$class = new ReflectionClass($this->nombreclase);
		$f=$class->getProperties();
		for($i=0;$i<sizeof($f);$i++){
			if($f[$i]->isPrivate()){
				if(!is_object($this->{$f[$i]->getName()}))
				echo "<br/>".$this->{$f[$i]->getName()};
				else
				$this->{$f[$i]->getName()}->muestraObjeto();
			}
		}
	}
	/**
	 * Metodo que carga objeto con resultset
	 *
	 * @param Object $obj
	 * @param ResultSet $rs
	 * @param bool $sn
	 */
	public function cargaRecursiva($obj,$rs, $sn){
		$class = new ReflectionClass($obj->nombreclase);
		$f=$class->getProperties();
		if(!$sn)
		$cant=$obj->getPk();
		else
		$cant=sizeof($f);
		for ($i = 0; $i < $cant; $i++) {
			if ($f[$i]->isPrivate()) {
				$aux = $rs[$f[$i]->getName()];
				if($aux!=null){
					if (!is_object($this->{$f[$i]->getName()})) {
						$obj->{$f[$i]->getName()}=$aux;
					} else {
						$class = new ReflectionClass($obj->{$f[$i]->getName()}->getNombreclase());
						$ob = $class->newInstance($this->bd);
						$obj->{$f[$i]->getName()}=$ob;
						cargaRecursiva($ob, $rs, false);
					}
				}
			}
		}
	}

	/**
	 * Esta función es la encargada de validar los atributos de clase.
	 *
	 * @param Object $obj
	 * @param String $campo
	 * @return bool
	 */
	private function validaCampo($obj, $campo){
		if(!is_object($obj->{$campo})){
			if(is_numeric($obj->{$campo})&&$obj->{$campo}<0)
			return false;

			if($obj->{$campo} == null || strlen($obj->{$campo})<0)
			return false;

			return true;
		}
		else{
			$class = new ReflectionClass($obj->{$campo}->getNombreclase());
			$a=$class->getProperties();
			$i=0;
			$sn = true;
			foreach ($a as $key => $valor){
				if($obj->{$campo}->getPk()>$i)
				$sn&=$this->validaCampo($obj->{$campo},$valor->getName());
				else
				return $sn;
				$i++;
			}
		}
	}
	/**
	 * Esta función es la encarga de obtener el valor de un atriibuto de una clase.
	 *
	 * @param Object $obj
	 * @param String $campo
	 * @return String
	 */
	private function getValor($obj,$campo){
		if(!is_object($obj->{$campo})){
			return "'".$obj->{$campo}."'";
		}
		else{
			$class = new ReflectionClass($obj->{$campo}->getNombreclase());
			$a=$class->getProperties();
			$i=0;
			$val="";
			foreach ($a as $key => $valor){
				if($obj->{$campo}->getPk()>$i){
					if(strlen($val)>0)
					$val.=",";
					$val.=$this->getValor($obj->{$campo},$valor->getName());
				}
				else
				return $val;
				$i++;
			}
		}
	}
	/**
	 * Esta función es la encargada de obtener los nombres de los atributos de una clase.
	 *
	 * @param Object $obj
	 * @param String $campo
	 * @return String
	 */
	private function getNombre($obj,$campo){
		if(!is_object($obj->{$campo})){
			return $campo;
		}
		else{
			$class = new ReflectionClass($obj->{$campo}->getNombreclase());
			$a=$class->getProperties();
			$i=0;
			$val="";
			foreach ($a as $key => $valor){
				if($obj->{$campo}->getPk()>$i){
					if(strlen($val)>0)
					$val.=",";
					$val.=$this->getNombre($obj->{$campo},$valor->getName());
				}
				else
				return $val;
				$i++;
			}
		}
	}
	/**
	 * Esta función se encarga de obtener el nombre de un atributo t su respectivo valor.
	 *
	 * @param Object $obj
	 * @param String $campo
	 */
	private function getNombreValor($obj, $campo){
		if(!is_object($obj->{$campo})){
			$this->retorno[$campo]="'".Cadenas::regresaSinComillas($obj->{$campo})."'";
		}
		else{
			$class = new ReflectionClass($obj->{$campo}->getNombreclase());
			$f=$class->getProperties();
			for($i=0;$i<$obj->{$campo}->getPk();$i++)
			$this->getNombreValor($obj->{$campo},$f[$i]->getName());
		}
	}
}
/*$a = new ReflectionProperty();
$a->getName();
$a->getModifiers();
$a->getDeclaringClass()->getName();*/
/*if(!is_object($this->{$valor->getName()})){
echo $valor->getName()."= ".$this->{$valor->getName()}." <br/>";
}
else{
echo $valor->getName()."= sinvalor <br/>";
echo "Clase: ".$this->{$valor->getName()}->{"nombreclase"}."<br/>";
}*/
?>
Return current item: Persistencia