/**
* cria os campos do formulario baseando-se na entidade informada
*
* @return DSForm
* */
public function factoryField()
{
$fields = array();
$columns = $this->_source->annotation()->load();
$columns = $columns->attrs;
foreach ($columns as $key => $column) {
$getter = $column->get;
$fields[$column->name] = $this->field($column, $this->_source->{$getter}());
}
$this->add($fields);
return $this;
}
/**
* Obtém o nome do método acessor e do atributo informados.
*
* @param string $typeAcessor
* @param string $attrAtribute
* @return string
* @throws IllegalArgumentException
*/
private function _getAcessorMethod($typeAcessor, $attrAtribute)
{
$this->_checkPropertyExists($attrAtribute);
IllegalArgumentException::throwsExceptionIfParamIsNull(in_array($typeAcessor, array('get', 'set')), 'Tipo de método acessor é inválido.');
$annotation = $this->_valueObject->annotation()->load();
$attrs = $annotation->attrs;
$attrValue = $attrs->{$attrAtribute};
return $attrValue->{$typeAcessor};
}
/**
* Função que monta os dados para pesquisa
* @param ValueObjectAbstract $valueObject
*/
protected function _preparePersist(ValueObjectAbstract $valueObject)
{
$arrVo = $valueObject->toArray();
$attrs = (array) $valueObject->annotation()->load()->attrs;
foreach ($arrVo as $key => $elmnt) {
if (isset($attrs[$key]->database)) {
if ('string' == $attrs[$key]->type && NULL != $elmnt) {
$elmnt = '%' . $elmnt . '%';
}
$this->_params[$key] = (object) array('type' => $attrs[$key]->type, 'value' => '' == $elmnt ? NULL : $elmnt);
}
}
}
/**
* retorna representacao textual do comando para alterar os dados
*
* @param ValueObjectAbstract
* @return string
* */
public function update(ValueObjectAbstract $valueObject)
{
$annon = $valueObject->annotation()->load();
$dmlQuery = $conditional = NULL;
foreach ($this->persistAttr($valueObject, 'update') as $column) {
# verifica se o campo eh uma chave primaira
if (isset($column->primaryKey)) {
$conditional .= sprintf(' %s %s = :%s', trim($conditional) ? 'AND' : 'WHERE', $column->database, $column->name);
continue;
}
$dmlQuery .= sprintf(', %s = :%s', $column->database, $column->name);
}
$dmlQuery = ltrim($dmlQuery, ', ');
# por questao de seguranca, nao sera permitido a alteracao
# de toda entidade, ou seja, seja necessario que ao menos
# uma PK exista na entidade
DMLException::throwsExceptionIfParamIsNull($conditional, self::T_DMLABSTRACT_FILTER_REQUIRED);
return sprintf('UPDATE %s SET %s%s', $this->_persist->getEntity($valueObject)->qualifiedName(), $dmlQuery, $conditional);
}
/**
* {@inheritdoc}
*/
public function isKeepHistory(ValueObjectAbstract $valueObject)
{
$info = $valueObject->annotation()->getClassDoc();
return isset($info['log']);
}
/**
* Efetua pesquisa por parametrizada.
*
* Se informado, o segundo paramentro $limit define o numero de resultado que será retornado. O terceiro pramentro
* $offSet que também é opcional define o registro inicial que sera contato o limite
*
* @param ValueObjectAbstract $valueObject
* @param integer $limit
* @param integer $offSet
* @return ValueObject[]
* @throws PersistException
* */
public function findByParam(ValueObjectAbstract $valueObject, $limit = 10, $offSet = 0)
{
try {
# recupera anotacao do valuObject
$tmpOperator = array('WHERE', 'AND');
$annon = $valueObject->annotation()->load();
$fieldData = $fieldList = array();
$filter = NULL;
# campos que devem ser utilizados para persistencia de database
$attrs = $this->_persist->persistAttr($valueObject, 'select');
foreach ($attrs as $attr) {
$fieldList[] = $attr->database;
$fieldData[$attr->database] = $this->_persist->getValue($valueObject, $attr->get, $attr->type);
if (NULL === $fieldData[$attr->database]->value) {
unset($fieldData[$attr->database]);
// @codeCoverageIgnoreStart
continue;
// @codeCoverageIgnoreEnd
}
# insere o campo na listagem de filtro
$filter .= sprintf(' %1$s %2$s = :%2$s', $tmpOperator[(bool) $filter], $attr->database);
}
# monta instrucao SQL de pesquisa
// @codeCoverageIgnoreStart
$queryString = sprintf('SELECT %s FROM %s%s', implode(', ', $fieldList), $annon->entity, $filter);
# se houver, aplica ordenacao
$queryString = $this->_persist->sorter($queryString);
# aplica limitacao da consulta
if ($limit != NULL && 0 < $limit && ($offSet != NULL && 0 < $offSet)) {
$queryString .= sprintf(' LIMIT %d, %d', (int) $offSet, (int) $limit);
} elseif ($limit != NULL && 0 < $limit) {
$queryString .= sprintf(' LIMIT %d', (int) $limit);
} elseif (0 > $limit) {
$queryString .= sprintf(' LIMIT %d', 0);
}
# executa a consulta
return $this->_persist->getConnect()->prepare($queryString, $fieldData)->retrieve();
} catch (\PDOException $pdoExc) {
throw new PersistException($pdoExc->getMessage(), 0);
}
}
/**
* Retorna lista de campos que compõe a entidade
*
* @param ValueObjectAbstract $valueObject
* @return string[]
* */
public function fetch(ValueObjectAbstract $valueObject)
{
$fields = array('field' => array(), 'value' => array());
$annon = $valueObject->annotation();
$infor = $annon->getClassDoc();
$attrs = $annon->getAttrsDoc();
$list = 'all' == strtolower($infor['log']) ? $this->fields($annon) : $this->translante($annon, explode(',', $infor['log']));
foreach ($list as $key => $field) {
$fields['field'][] = $field;
$fields['value'][] = self::getValueRecursively($valueObject, $attrs[$key]['get']);
}
return $fields;
}
/**
* Função que monta os dados para pesquisa
* @param ValueObjectAbstract $valueObject
*/
private function _preparePersist(ValueObjectAbstract $valueObject)
{
$arrResult = array();
$arrVo = array_filter($valueObject->toArray());
$attrs = (array) $valueObject->annotation()->load()->attrs;
foreach ($arrVo as $key => $elmnt) {
$arrResult[$key] = (object) array('type' => $attrs[$key]->type, 'value' => $elmnt);
}
return $arrResult;
}
/**
* Método construtor.
* Recupera a relação dos campos a realizar o log de auditoria e a relação dos atributos do VO.
* @param ValueObjectAbstract $valueObject
* @param string $pathLeaf
* @param mixed $pathLeaf
* @throws \br\gov\sial\core\persist\exception\PersistException
* */
public function __construct(ValueObjectAbstract $valueObject, $pathLeaf = NULL, $upload = NULL)
{
self::$_config['logFields'] = self::getIfDefined($valueObject->annotation()->load(), 'log') ? $valueObject->annotation()->load()->log : NULL;
self::$_config['xmlStruct'] = NULL;
self::$_config['xmlContent'] = NULL;
self::$_config['xmlContentLog'] = NULL;
self::$_config['attrs'] = $valueObject->annotation()->load()->attrs;
self::$_config['timeStamp'] = date("D, d M Y H:i:s");
self::$_config['namespace'] = $this->getClassName();
self::$_config['valueObject'] = $valueObject;
self::$_config['upload'] = $upload;
# $pathLeaf
self::$_config['path'] = $pathLeaf;
}
/**
* Prepara o comando que será executado no repositório.
*
* @param [string|string[] ]$query
* @param stdClass[] $params
* @return Connect
* */
public function prepare(ValueObjectAbstract $voQuery, $params)
{
$attrs = (array) $voQuery->annotation()->load()->attrs;
$sial_queryFields = array();
foreach ($attrs as $field) {
if ($attr = self::getIfDefined($field, 'ldap')) {
$this->_ldapParam[] = $field->ldap;
$getMethod = $field->get;
$this->_ldapFilter[$field->ldap] = $voQuery->{$getMethod}();
}
if ($attr = self::getIfDefined($field, 'keyLdap')) {
$this->_ldapKey = $field->keyLdap;
}
}
$this->_ldapMethod = $params;
return $this;
}
/**
* retorna apenas os dados das chaves primarias
*
* @param ValueObject
* */
public function primaryKey(ValueObjectAbstract $valueObject)
{
$annon = $valueObject->annotation()->load();
$attrs = NULL;
foreach ($annon->attrs as $column) {
if (self::_isPrimaryKey($column)) {
$attrs[] = $column->name;
}
}
return self::get($valueObject, $attrs);
}
/**
* copia o conteudo, dos atributos avaliados como vazio do objeto atual, do valueObjet informado
*
* Nota: Este metodo só funciona com objetos de mesmo tipo
*
* @param ValueObjectAbstract $source
* @return ValueObjectAbstract
* */
public function copySaveObjectData(self $source)
{
$ttype = $this->annotation();
$tdata = $this->toArray();
$sdata = $source->toArray();
ValueObjectException::throwsExceptionIfParamIsNull($source->annotation()->getClassName() == $ttype->getClassName(), self::T_VALUEOBJECT_OPERATION_REQUIRE_SOME_OBJECT);
# copia os dados da origem para destino
foreach ($ttype->getAttrsDoc() as $attr) {
$name = $attr['name'];
$setter = $attr['set'];
# quando o valor for um array isso indica uma chave estrangeira, assim, pega-se a
# mesma chave e busca no array.
if (is_array($sdata[$name])) {
$sdata[$name] = isset($attr['foreingKeyAlias']) ? $sdata[$name][$attr['foreingKeyAlias']] : $sdata[$name][$name];
}
# se attr local estiver vazio entao preenche-o com o
# dado do valueObject informado
if (is_array($tdata[$name])) {
$tdata[$name] = isset($attr['foreingKeyAlias']) ? $tdata[$name][$attr['foreingKeyAlias']] : ($tdata[$name] = $tdata[$name][$name]);
}
# preenche o attr deste VO se o attr estiver vazio
if ('boolean' != gettype($tdata[$name]) && '' == $tdata[$name] || 'boolean' != gettype($tdata[$name]) && FALSE === $tdata[$name]) {
$this->{$setter}($sdata[$name]);
}
}
return $this;
}
/**
* Injeta os valores recuperados do banco no ValueObject.
*
* @param ValueObjectAbstract $valueObject
* @param ResultSet $resultSet
* */
protected static function _injectResultOnValueObject(ValueObjectAbstract $valueObject, ResultSet $resultSet)
{
$adapter = self::PERSIST_TYPE;
$annon = $valueObject->annotation()->load();
$tmpRow = $tmpResult = NULL;
while (TRUE) {
$tmpRow = $resultSet->fetch();
if (NULL == $tmpRow) {
// @codeCoverageIgnoreStart
break;
// @codeCoverageIgnoreEnd
}
$tmpResult = $tmpRow;
}
foreach ($annon->attrs as $attr) {
if (isset($attr->set) && isset($attr->{$adapter})) {
$setter = $attr->set;
$fName = $attr->{$adapter};
$valueObject->{$setter}($tmpResult ? parent::getIfDefined($tmpResult, $fName) : NULL);
}
}
}
/**
* Deleta dados no repositório.
*
* @param ValueObjectAbstract $valueObject
* @return br\gov\sial\core\persist\Persist
* @throws PersistException
* */
public function delete(ValueObjectAbstract $valueObject)
{
$annon = $valueObject->annotation()->load();
$tmpFilter = NULL;
# tecnica explicada no metodo findByParam
$tmpOperator = array('WHERE', 'AND');
foreach ($annon->attrs as $field) {
if (!isset($field->database) || !isset($field->primaryKey)) {
// @codeCoverageIgnoreStart
continue;
// @codeCoverageIgnoreEnd
}
$tmpFilter .= sprintf(' %1$s %2$s = :%2$s', $tmpOperator[(bool) $tmpFilter], $field->database);
$params[$field->database] = self::_getValue($valueObject, $field->get, $field->type);
}
# por padrao nao eh possivel atualizar toda a entidade, se realmente for necessario realizar
# esta operacao sobreescreve este metodo
PersistException::throwsExceptionIfParamIsNull($tmpFilter, sprintf(self::PERSIST_UNAVAILABLE_DELETE_FILTER, $annon->entity));
$query = sprintf('DELETE FROM %s %s', $annon->entity, $tmpFilter);
$this->_persist->getConnect()->prepare($query, $params)->update();
}
/**
* Retorna todos os atributos do valueObject que podem ser utilizados na camada de persistência, definida por
* 'self::PERSIST_TYPE'. Opcionalmente, o tipo da operacao podera ser informada (insert, update, delete). Nota:
* Por padrao os atributos selecionados serao validos para pesquisa.
*
* @param ValueObjectAbstract $valueObject
* @param string $operType
* @return \stdClass
* @throws PersistException
* */
public function persistAttr(ValueObjectAbstract $valueObject, $operType = NULL)
{
$annon = $valueObject->annotation()->load();
$list = array();
if (NULL !== $operType) {
$method = '_persistAttr' . ucfirst(strtolower($operType));
$message = sprintf(self::T_DMLABSTRACT_UNSUPPORTED_OPERATION, $method);
DMLException::throwsExceptionIfParamIsNull($this->hasMethod($method), $message);
}
foreach ($annon->attrs as $attr) {
# verifica se o attr pode ser manipulado pela camada de persistencia
if (FALSE == $this->_persist->isAttrPersistable($attr, $this->_persist->adapter())) {
continue;
}
if (NULL !== $operType) {
$this->{$method}($list, $attr, $valueObject);
}
}
return $list;
}
/**
* Prepara os parâmetros para consulta do LDAP.
*
* @param ValueObjectAbstract $valueObject
* @return array[]
*/
private function _prepareLdapParams(ValueObjectAbstract $valueObject)
{
$annon = $valueObject->annotation()->load();
foreach ($annon->attrs as $field) {
if ($attr = self::getIfDefined($field, 'ldap')) {
$get = $field->get;
$params[$field->ldap] = $valueObject->{$get}();
}
if ($attr = self::getIfDefined($field, 'keyLdap')) {
$params['keyLdap'] = $field->keyLdap;
}
}
return $params;
}
