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());
}
}
/**
* Nesse método cada classe é persistida de acordo
* com as suas características, permite inclusive
* usar base de dados diferentes
*/
public function save2()
{
/*
* Substitui a variável $mainObject por $this que recupera os
* dados da classe filha.
*/
$phpDocMainObject = new PHPDoc($this->class);
// recupera as propriedades da classe
$this->properties = $phpDocMainObject->getProperties();
// verificar se a chave primaria foi definida
# recupera os atributos da classe principal
//foreach ( $this->properties [get_class( $this )] as $vProperties ) {
foreach ($this->properties[$this->class] as $vProperties) {
// verificar se a chave primaria foi definida
if ($phpDocMainObject->getPK() == $vProperties) {
if (is_null($this->__get($vProperties))) {
# PK não definida: insert
continue;
} else {
# PK definida: update, clausula where necessária
$where[$vProperties] = $this->__get($vProperties);
continue;
}
}
$mainData[$vProperties] = $this->__get($vProperties);
}
parent::getLink()->beginTransaction();
if (is_null($this->__get($phpDocMainObject->getPK()))) {
# se PK = null: insert
try {
# insere um novo objeto no banco de dados
$this->insert()->add($mainData, PREFIX_TABLE . $this->getClass());
$this->execute();
//$this->insert ( $mainData, PREFIX_TABLE.$this->getClass() );
# salva a transação
//$this->conexao->commit();
parent::getLink()->commit();
# Quando um novo objeto é criado deve-se recuperar o id do objeto principal
# e passa-lo para a FK correspondente
$this->__set($phpDocMainObject->getPK(), $this->lastInsertId());
} catch (PDOException $e) {
# se ocorrer exceção na classe principal, o script deverá ser cancelado.
//$this->conexao->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());
}
} else {
try {
# se ocorrer exceção na classe principal, o script deverá ser cancelado.
# se a chave primária for definida, realizar update
$this->update()->add($mainData, $where, PREFIX_TABLE . $this->getClass());
$this->execute();
# salva a transação
//$this->conexao->commit();
parent::getLink()->commit();
//$this->link->commit();
} catch (PDOException $e) {
# se ocorrer exceção na classe principal, o script deverá ser cancelado.
//$this->conexao->rollBack();
parent::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());
}
//debug(__LINE__, "linhas afetadas: ".$this->getNumberRows() );
}
}
/**
* 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;
}
