/**
* Esse método é destinado a recuperar um objeto da base de dados
* recebe como parâmetro a própria classe, pois todas as classes
* persistentes são dependentes de "class Persistencia".
* a Classe PHPDoc recupera a documentação da classe principal e
* utiliza as informações para obter os dados persistentes e após
* cada atributo da classe principal é carregado dinamicamente. Uma
* classe principal pode possuir atributos compostos que são derivados
* de outras classes (chamadas de classes derivadas), esse método também
* obtém os registros persitentes das classes derivadas e alimenta o
* atributo composto com um array de objetos, garantindo assim que
* os princípios da OO sejam garantidos.
*/
public function get()
{
# documentação da classe principal
$docClassePrincipal = new PHPDoc(get_class($this));
# recupera as propriedades da classe principal
$this->properties = $docClassePrincipal->getProperties();
# recupera a chave primária da clase principal
$this->pk = $docClassePrincipal->getPK();
# instância para um objeto do tipo select
$select = $this->oSQL->select();
# $this->properties[$this->class]: contém todos os atributos com a tag @column
# o método add recebe e prepara a tabela e os campos da consulta
$select->add($this->getTable(), $this->properties[$this->class]);
/*
* a cláusula where é obrigatória, pois o método get pode retornar
* apenas um objeto.
*/
$select->where($docClassePrincipal->getPK(), "=", $this->__get($docClassePrincipal->getPK()));
# $result: recebe o resultado da consulta SQL a base de dados executada pelo método execute()
$result = $this->oSQL->execute();
/*
* Aqui ocorre o carregamento dos atributos da classe principal
* a variável $result contém os dados obtidos e a variável
* $this->properties contém a lista de atributos da classe
* para validação dos dados. Pode ocorrer de retornar algum
* registro da base de dados não suportado pela classe. Tipo
* registro de controle como um campo timestamp.
* O sistema procura por dados das classes derivadas apenas se houver
* resultado na pesquisa da classe principal.
*/
if (!empty($result)) {
foreach ($this->properties[$this->class] as $atributo) {
$this->__set($atributo, $result[0][$atributo]);
}
/*
* Esse código retira os atributos da classe principal
* do array de propriedades. Permanecerão apenas as classes
* derivadas, quando houver.
*/
unset($this->properties[$this->class]);
/*
* A variável $this->properties armazena um array contendo todos os atributos
* da classe. Na operação anterior, é eliminado desse array, os atributos da
* classe principal. Se a classe principal possuir atributos vinculados a outras
* classes, esses permanecerão para que cada um dos objetos derivados seja criado
* e adicionado como atributo na classe principal.
*/
if (!empty($this->properties)) {
foreach ($this->properties as $classeDerivada => $vAtributo) {
// $classeDerivada = classe do atributo (propertie). Ex: \<namespace>\Telefone
// $vAttribute = nome do atributo pertencente a classe $derivedClass. Ex: idTelefone
# Instância de um objeto derivado
$oObjetoDerivado = new $classeDerivada();
# $result: armazena um array de objetos derivados
$result = $oObjetoDerivado->getAllObject(array($docClassePrincipal->getPK() => $this->__get($docClassePrincipal->getPK())));
# Retirar o namespace da classe derivada
$nomeClasseDerivada = explode('\\', $classeDerivada);
/*
* O bloco if verifica se há método, na classe principal, para tratamento dos dados
* obtidos na classe derivada.
* Ex:
* private $telefone = array(); atributo de origem na classe Telefone
*
* public function setTelefone(){}; método para tratamento dos dados
*/
if (!empty($result)) {
if ($docClassePrincipal->hasMethod('set' . end($nomeClasseDerivada))) {
# $phpDocMainObject->getMethod( 'set'.$derivedClass )->invoke( $this->object, $oDerivedObject );
foreach ($result as $objeto) {
$docClassePrincipal->getMethod('set' . end($nomeClasseDerivada))->invoke($this, $objeto);
}
}
}
}
#foreach
}
#fim: !empty ( $this->properties )
} else {
$this->__set($docClassePrincipal->getPK(), null);
}
}
/**
*
*/
public function getBackup()
{
# documentação da classe principal
$phpDocMainObject = new PHPDoc($this->class);
// recupera as propriedades da classe principal
$this->properties = $phpDocMainObject->getProperties();
// recupera a chave primária da tabela principal
$this->pk = $phpDocMainObject->getPK();
// recupera os atributos da classe principal
# --->$result = $this->select( $this->getTable(), $this->properties[$this->class], array(array( $this->pk,"=",$this->object->__get( $this->pk ) ) ) );
$this->select()->column(array($this->getTable() => $this->properties[$this->class]));
if (!is_null($this->object->__get($phpDocMainObject->getPK()))) {
$this->select()->where($phpDocMainObject->getPK(), "=", $this->object->__get($phpDocMainObject->getPK()));
}
// $this->setAttributes( $this->execute() );
$result = $this->execute();
// echo "linha 141: (result)".count( $result )."<pre>";
// print_r($result);
// echo "</pre>";
if (!empty($result)) {
foreach ($this->properties[$this->class] as $value1) {
if ($phpDocMainObject->hasMethod('set' . ucfirst($value1))) {
$phpDocMainObject->getMethod('set' . ucfirst($value1))->invoke($this->object, $result[0][$value1]);
} else {
# Define os atributos da classe principal
$this->object->__set($value1, $result[0][$value1]);
}
}
# fim do foreach
unset($method);
}
// retiro a classe principal do array
// se houver dados no array são pertencentes aos atributos
// das classes derivadas
unset($this->properties[$this->class]);
/*
* A variável $this->properties armazena um array contendo todos os atributos
* da classe. Na operação anterior, é eliminado desse array, os atributos da
* classe principal. Se a classe principal possuir atributos vinculados a outras
* classes, esses permanecerão para que cada um dos objetos derivados seja criado
* e adicionado como atributo na classe principal.
*/
if (!empty($this->properties)) {
foreach ($this->properties as $derivedClass => $vAttribute) {
// $derivedClass = classe do atributo (propertie). Ex: Telefone
// $vAttribute = nome do atributo pertencente a classe $derivedClass. Ex: idTelefone
$phpDocDerivedObject = new PHPDoc($derivedClass);
$properties = $phpDocDerivedObject->getProperties();
// recupera os dados das classes derivadas
// $result = $this->select( PREFIX_TABLE.$derivedClass, $properties[ $derivedClass ], array(array( $this->pk,"=",$id ) ) );
$this->setTable($derivedClass);
$this->select()->column(array($this->getTable() => $properties[$derivedClass]));
# @TODO a fk deve ser obrigatória, rever esse código
if (!is_null($this->object->__get($phpDocMainObject->getPK()))) {
$this->select()->where($phpDocMainObject->getPK(), "=", $this->object->__get($phpDocMainObject->getPK()));
}
$result = $this->execute();
if (!empty($result)) {
foreach ($result as $kResult => $vResult) {
// instância da classe derivada
$oDerivedObject = new $derivedClass();
foreach ($properties[$derivedClass] as $vProperties) {
#@TODO verificar qual a função desse código.
if ($phpDocDerivedObject->getPK() == $vProperties) {
$pk = $vResult[$vProperties];
}
# definição dos atributos da classe derivada
$oDerivedObject->__set($vProperties, $vResult[$vProperties]);
}
#fim do foreach
# Retirar o namespace da classe derivada
$teste = explode('\\', $derivedClass);
/*
* O bloco if verifica se há método, na classe principal, para tratamento dos dados
* obtidos na classe derivada.
* Ex:
* private $telefone = array(); atributo de origem na classe Telefone
*
* public function setTelefone(){}; método para tratamento dos dados
*/
if ($phpDocMainObject->hasMethod('set' . end($teste))) {
# $phpDocMainObject->getMethod( 'set'.$derivedClass )->invoke( $this->object, $oDerivedObject );
$phpDocMainObject->getMethod('set' . end($teste))->invoke($this->object, $oDerivedObject);
}
}
}
}
#fim: foreach das classes derivadas
}
#fim: !empty ( $this->properties )
return $this->object;
}
/**
* Recupera um array de objetos de uma consulta do tipo getAll;
* @return array
*/
protected function getArrayList()
{
# documentação da classe principal
$phpDocMainObject = new PHPDoc($this->class);
# recupera as propriedades da classe principal
$this->properties = $phpDocMainObject->getProperties();
# recupera a chave primária da tabela principal
$this->pk = $phpDocMainObject->getPK();
# Criação de instância, prepração do select e recuperação do array de dados
$oSelect = new Select();
#$this->properties[$this->class]: lista de atributos da classe principal, não contempla os atributos originários de outra tabela
$oSelect->select(array($this->getTable()), $this->properties[$this->class]);
# $result: armazena o resultado da consulta ao banco de dados.
$arrayListClassePrincipal = $this->select($oSelect);
# retira os atributos da classe principal da lista de atributos
unset($this->properties[$this->class]);
# $vArrayListAttributes: lista de atributos da classe principal. Ex: idCustomer, customer.
# $kArrayList: índice numérico do resultado.
foreach ($arrayListClassePrincipal as $kArrayList => $vArrayListAttributes) {
$classePrincipal = new $this->class();
foreach ($vArrayListAttributes as $atributo => $valor) {
$classePrincipal->__set($atributo, $valor);
}
#$this->properties: lista de atributos da classe principal que tem origem em outra tabela.
if (!empty($this->properties)) {
foreach ($this->properties as $derivedClass => $vAttribute) {
# $derivedClass = classe do atributo (propertie)
# $vAttribute = nome do atributo pertencente a classe $derivedClass
# cria uma instância do PHPDoc com a classe de origem do atributo
$phpDocDerivedObject = new PHPDoc($derivedClass);
# recupera as propriedades da classe
$properties = $phpDocDerivedObject->getProperties();
# recupera o nome da tabela mapeada para a classe. Ex: classe = Cliente, tabela = tab_Cliente;
# a classe está no padrão do namespace, requer tratamento pelo setDerivedTable;
$this->setDerivedTable($derivedClass);
# Criação de instância, prepração do select e recuperação do array de dados
$oSelect = new Select();
$oSelect->select(array($this->derivedTable), $properties[$derivedClass]);
# adiciona uma restrição a cláusula where, nesse caso limita a consulta pela chave estrangeira
$oSelect->addWhere($this->pk, "=", $vArrayListAttributes[$this->pk]);
$arrayListClasseDerivada = $this->select($oSelect);
#echo $vAttribute;
#$this->arrayListClasseDerivada[$vAttribute] = $arrayListClasseDerivada;
foreach ($arrayListClasseDerivada as $atributo => $valor) {
# cria uma instância da classe derivada
$objetoDerivado = new $derivedClass();
# monta os atributos da classe derivada
foreach ($properties[$derivedClass] as $valorPropriedade) {
$objetoDerivado->__set($valorPropriedade, $valor[$valorPropriedade]);
}
# cria um array com os elementos da classe derivada por motivo do namespace
$derived_class = explode('\\', $derivedClass);
#necessário para não interferir no nome qualificado da classe
if (!empty($arrayListClasseDerivada)) {
if ($phpDocMainObject->hasMethod('set' . end($derived_class))) {
#$phpDocMainObject->getMethod( 'set'.end( $derived_class ) )->invoke( $classePrincipal, $objetoDerivado );
}
}
# verifica se o método existe na classe principal - usa o nome do atributo
if (!empty($arrayListClasseDerivada)) {
if ($phpDocMainObject->hasMethod('set' . ucfirst($vAttribute))) {
$phpDocMainObject->getMethod('set' . ucfirst($vAttribute))->invoke($classePrincipal, $objetoDerivado);
}
}
}
}
#foreach( $result as $kClassePrincial => $vClassePrincipal )
}
#if (! empty ( $this->properties ))
$arrayList[] = $classePrincipal;
}
#foreach( $arrayListClassePrincipal as $kArrayList => $vArrayListAttributes )
return $arrayList;
}
