/**
* Salva (insere) ou atualiza (update) um registro
*
* Este metodo e um pouco diferente do que somente o save.
* Ele checa se existe uma chave primaria auto-incrementavel.
* Se existir, usa o save normal, se nao existir, ira buscar os
* registros com base nas chaves primarias encontradas e os valores
* encontrados nos dados informados para persistencia.
*
* Se encontrar algum registro com as chaves informadas, ira atualizar,
* do contrario insere.
*
* @author Hugo Ferreira da silva
* @link http://www.hufersil.com.br
* @param $data
* @return unknown_type
*/
public function saveOrUpdate(array $data)
{
$this->obj->reset();
$pks = $this->obj->metadata()->getPrimaryKeys();
$hasAutoInc = false;
foreach ($pks as $pk) {
if (!empty($pk['options']['autoincrement'])) {
$hasAutoInc = true;
break;
}
$name = $pk['name'];
$this->obj->{$name} = array_key_exists($name, $data) ? $data[$name] : null;
}
if ($hasAutoInc) {
return $this->save($data);
}
$total = $this->obj->count();
$this->obj->populateFrom($data);
if ($total == 0) {
$this->obj->insert();
} else {
$this->obj->save();
}
return 0;
}
/**
* Recupera os metadados do campo
*
* @param Lumine_Base $target
* @author Hugo Ferreira da Silva
*/
public function getFieldMetadata(Lumine_Base $target)
{
$result = null;
try {
$result = $target->metadata()->getField($this->getField());
} catch (Exception $e) {
}
return $result;
}
/**
* Recupera o dialeto para o objeto
*
* @author Hugo Ferreira da Silva
* @link http://www.hufersil.com.br/
* @param Lumine_Base $obj
* @return Lumine_Dialect_IDialect
*/
public static function get(Lumine_Base $obj)
{
$dialect = $obj->_getConfiguration()->getProperty('dialect');
$id = $obj->_getObjectPart('_objectID');
if (!array_key_exists($dialect, self::$createdItems)) {
Lumine::load('Lumine_Dialect_' . $dialect);
$ref = new ReflectionClass('Lumine_Dialect_' . $dialect);
self::$createdItems[$dialect] = $ref->newInstance();
}
self::$createdItems[$dialect]->setConnection($obj->_getConnection());
self::$createdItems[$dialect]->setObjectId($id);
self::$createdItems[$dialect]->setTablename($obj->metadata()->getTablename());
return self::$createdItems[$dialect];
}
/**
* Recupera os nos filhos de uma arvore
*
* Efetua a consulta uma unica vez.
* Depois que os nos filhos estao populados, sempre
* utiliza os nos encontrados
*
* @author Hugo Ferreira da Silva
* @param boolean $loadSubChilds Indica se os filhos deverao carregar seus sub-filhos
* @return Lumine_Tree_NodeList
*/
public function getChildNodes($loadSubChilds = false)
{
// se ainda nao buscou os nos filhos
if (is_null($this->childNodes)) {
// cria um node list
$this->childNodes = new Lumine_Tree_NodeList();
// pega o codigo deste objeto
$code = $this->obj->{$this->fieldId};
// se tiver um codigo
if (!is_null($code)) {
// inicia a reflexao
$ref = new ReflectionClass($this->obj->metadata()->getClassname());
// recupera uma nova instancia
$inst = $ref->newInstance();
// consulta os filhos
$inst->where('{' . $this->fieldParentId . '} = ?', $code)->find();
// para cada filho encontrado
while ($inst->fetch()) {
// cria uma nova instancia
$temp = $ref->newInstanceArgs();
// popula com os dados encontrados
$temp->populateFrom($inst->toArray());
// cria um no
$node = new Lumine_Tree_Node($temp, $this->fieldId, $this->fieldParentId);
// informa que este objeto eh o parentNode
$node->parentNode = $this;
if (!is_null($this->getTree())) {
// informa a arvore
$node->setTree($this->getTree());
}
if ($loadSubChilds) {
$node->getChildNodes($loadSubChilds);
}
// coloca na lista
$this->childNodes->add($node);
}
// destroi o objetode consulta
$inst->destroy();
}
}
// retorna os nos filhos
return $this->childNodes;
}
/**
* Insere o registro enviado no banco de dados
*
* @author Hugo Ferreira da Silva
* @link http://www.hufersil.com.br/
* @param array $values valores do formulario
* @return array resultado da validacao
*/
private function insert($values)
{
$def = $this->obj->metadata()->getFields();
foreach ($def as $name => $prop) {
if (!empty($prop['options']['foreign']) && empty($values[$name])) {
$this->obj->setFieldValue($name, null);
} else {
if ($this->strip_slashes) {
$this->obj->setFieldValue($name, stripslashes(@$values[$name]));
} else {
$this->obj->setFieldValue($name, @$values[$name]);
}
}
}
// limpamos as pk's que sao auto-incrementaveis
$obj =& $this->obj;
$pks = $obj->metadata()->getPrimaryKeys();
foreach ($pks as $name => $item) {
if (!empty($item['options']['autoincrement'])) {
$obj->{$item}['name'] = null;
}
}
// atualiza as referencias MTM
$def = $obj->metadata()->getRelations(FALSE);
foreach ($def as $name => $prop) {
if ($prop['type'] == Lumine_Metadata::MANY_TO_MANY) {
$obj->removeAll($name);
if (!empty($values[$name])) {
foreach ($values[$name] as $id) {
$obj->{$name}[] = $id;
}
}
}
}
// $this->obj->populateFrom($values);
$res = $this->obj->validate();
if ($res === true) {
$this->obj->insert();
return true;
}
return $res;
}
/**
* Permite adicionar um JOIN com uma expressao livre.
*
* @param Lumine_Base $obj Objeto que sera unido
* @param string $expression Expressao que sera utilizada no join
* @param string $alias Apelido para a classe que esta sendo unida
* @author Hugo Ferreira da Silva
* @return Lumine_Base o proprio objeto
*/
public function joinExpression($obj, $type, $expression, $alias = null)
{
$type = trim(strtoupper($type));
if (!preg_match('@^(LEFT|LEFT OUTER|INNER|RIGHT|RIGHT OUTER|CROSS)$@', $type)) {
throw new Lumine_Exception('Tipo nao suportado: ' . $type, Lumine_Exception::ERROR);
}
// se indicar o alias
if (!is_null($alias)) {
$obj->alias($alias);
} else {
$alias = $obj->alias();
if (empty($alias)) {
$alias = $obj->metadata()->getTablename();
}
}
// pega a lista de join's do objeto que esta sendo unido
$list = $obj->_getObjectPart('_join_list');
// reinicia a lista de join's deste objeto
reset($this->_join_list);
// argumentos extras
$args = func_get_args();
array_splice($args, 0, 4);
$expression = trim($expression);
// remove espacos em branco
try {
$expression = Lumine_Parser::parsePart($obj, $expression, $args);
// faz o parser para certificacao que os campos existem certinho
$expression = Lumine_Parser::parseEntityNames($obj, $expression);
} catch (Exception $e) {
try {
$expression = Lumine_Parser::parsePart($this, $expression, $args);
// faz o parser para certificacao que os campos existem certinho
$expression = Lumine_Parser::parseEntityNames($this, $expression);
} catch (Exception $e) {
Lumine_Log::warning('Houve um erro na analise da condicao extra');
}
}
// adiciona a expressao
$this->_join[] = sprintf('%s JOIN %s %s ON %s', $type, $obj->metadata()->getTablename(), $alias, $expression);
// para cada item na lista do objeto alvo
foreach ($list as $ent) {
// indica que pode adicionar
$add = true;
// para cada item na lista deste objeto
foreach ($this->_join_list as $this_ent) {
// se for a mesma classe e tiver o mesmo alias
if ($ent->metadata()->getClassname() == $this_ent->metadata()->getClassname() && $ent->alias() == $this_ent->alias()) {
// nao pode fazer o join
$add = false;
break;
}
}
// se nao puder fazer o join
if (!$add) {
// pula para o proximo item
continue;
}
// ok pode adicionar
$this->_join_list[] = $ent;
$this->_join = array_merge($this->_join, $ent->_getStrJoinList());
// faz o where
$where = $ent->_makeWhereFromFields();
// se teve condicoes
if (!empty($where)) {
// inclui neste objeto
$this->where($where);
}
}
// deixa a lista unica
$this->_join = array_unique($this->_join);
return $this;
}
/**
* Tenta recuperar dinamicamente os campos de identificacao
*
* Para trabalhar com uma estrutura de arvore,
* e necessario que a tabela tenha:
* - Uma unica chave primaria
* - Uma chave estrangeira (FK) que referencie a chave primaria.
*
* Nestas condicoes, Lumine consegue identificar quais sao os campos
* que compoe a arvore a partir de um dado objeto
*
* @author Hugo Ferreira da Silva
* @param Lumine_Base $pObj
* @return array Contendo os campos identificadores
*/
public static function getTreeFields(Lumine_Base $pObj)
{
$pFieldID = null;
$pFieldParentId = null;
// pega as definicoes do objeto
$def = $pObj->metadata()->getFields();
// chave primaria
$pk = null;
// para cada definicao
foreach ($def as $name => $item) {
// se for chave primaria
if (!empty($item['options']['primary'])) {
// armazenamos seus dados
$pk = $item;
$pk['name'] = $name;
continue;
}
// se for chave estrangeira
if (!empty($item['options']['foreign'])) {
// se o campo de linkagem for igual a pk e o nome da classe for o nome do objeto
if ($item['options']['linkOn'] == $pk['name'] && $item['options']['class'] == $pObj->metadata()->getClassname()) {
// encontramos os campos!
$pFieldId = $pk['name'];
$pFieldParentId = $name;
break;
}
}
}
// se continuar nulo
if (is_null($pFieldId) && is_null($pFieldParentId)) {
// dispara excecao
new Lumine_Exception('Os campos indicativos de arvore devem ser informados!');
}
$data['fieldId'] = $pFieldId;
$data['fieldParentId'] = $pFieldParentId;
return $data;
}
/**
* Faz o parse de nomes de colunas e tabelas de uma string
*
* @author Hugo Ferreira da Silva
* @link http://www.hufersil.com.br/
* @param Lumine_Base $obj
* @param string $str
* @return string
*/
public static function parseEntityNames(Lumine_Base $obj, $str)
{
// fazer parse de u.nome (alias + . + nome_do_campo) de cada entidade
$list = $obj->_getObjectPart('_join_list');
foreach ($list as $ent) {
$a = $ent->alias();
$name = $ent->metadata()->getClassname();
if (!empty($a)) {
preg_match_all('@\\b' . $a . '\\b\\.(\\w+)\\b@', $str, $reg);
$total = count($reg[0]);
for ($i = 0; $i < $total; $i++) {
$field = $ent->metadata()->getField($reg[1][$i]);
$exp = '@\\b' . $a . '\\b\\.(' . $reg[1][$i] . ')\\b@';
$str = preg_replace($exp, $a . '.' . $field['column'], $str);
}
}
preg_match_all('@\\{' . $name . '\\.(\\w+)\\}@', $str, $reg);
$total = count($reg[0]);
for ($i = 0; $i < $total; $i++) {
$field = $ent->metadata()->getField($reg[1][$i]);
if (!empty($a)) {
$str = str_replace($reg[0][$i], $a . '.' . $field['column'], $str);
} else {
$str = str_replace($reg[0][$i], $ent->metadata()->getTablename() . '.' . $field['column'], $str);
}
}
}
// encontra por {propriedade}
// quando nao especificado, significa que pertence a mesma entidade
// chamadora da funcao, por isso nao fazemos loop
preg_match_all('@\\{(\\w+)\\}@', $str, $reg);
$total = count($reg[0]);
for ($i = 0; $i < $total; $i++) {
$f = $obj->metadata()->getField($reg[1][$i]);
$a = $obj->alias();
if ($a == '') {
$a = $obj->metadata()->getTablename();
}
$str = str_replace($reg[0][$i], $a . '.' . $f['column'], $str);
}
return $str;
}
