Пример #1
0
 public function delete($id)
 {
     $phpDocMainObject = new PHPDoc(get_class($this));
     # recupera as propriedades da classe
     $this->properties = $phpDocMainObject->getProperties();
     $pk = $phpDocMainObject->getPK();
     $delete = $this->oSQL->delete();
     $delete->add($this->table);
     $delete->where($pk, '=', $id);
     $this->oSQL->getLink()->beginTransaction();
     try {
         $this->oSQL->execute();
         $this->oSQL->getLink()->commit();
     } catch (\PDOException $e) {
         //@TODO Tratar exceção
         # se ocorrer exceção
         # 1 - desfazer a transação
         # 2 - capturar o erro
         # 3 - armazenar o erro
         # 4 - apresentar tela de erro (ver os tipos de erros e consequências)
         # se ocorrer exceção na classe principal, o script deverá ser cancelado.
         $this->oSQL->getLink()->rollBack();
         /*
          * Se ocorrer excessão, os dados são passados para a classe de controle
          * de excessão do framework. Essa classe gerencia os dados que são passados
          * na interface do usuário e fornece as opções para solução do problema.
          */
         excecao::debugException($e->getMessage(), $e->getCode(), $e->getTrace());
     }
 }
Пример #2
0
 /**
  * Recupera um conjunto de ojetos armazenado em array,
  * é utilizado para recupear mais de um objeto e tambem
  * utilizado para 
  * @param array $restrict
  * $parametros = array(propriedade1=>valor, propriedade2=>valor);
  */
 public function getArrayObject(array $parametros)
 {
     # documentação da classe principal
     $phpDocMainObject = new PHPDoc(get_class($this));
     $namespaceClass = get_class($this);
     // 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]));
     foreach ($parametros as $atributo => $valor) {
         $this->select()->where($atributo, "=", $valor);
     }
     $result = $this->execute();
     if (!empty($result)) {
         foreach ($result as $key => $objeto) {
             # cria uma instância do objeto
             $oObject = new $namespaceClass();
             foreach ($this->properties[get_class($this)] as $key => $atributoClasse) {
                 $oObject->__set($atributoClasse, $objeto[$atributoClasse]);
             }
             $arrayObjetosSaida[] = $oObject;
             unset($oObject);
         }
         //debug(__FILE__,__LINE__, $arrayObjetosSaida);
         return $arrayObjetosSaida;
     }
     return array();
 }
Пример #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;
 }