示例#1
0
 /**
  * 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);
     }
 }
示例#2
0
 /**
  *
  */
 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;
 }
示例#3
0
 /**
  * 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;
 }