Example #1
0
 /**
  * @param Lumine_Base $obj Objeto a ser validado
  * @return array - Retorna array contendo erros caso validacao invalida
  * @author Cairo Lincoln de Morais Noleto
  * @link http://caironoleto.wordpress.com
  * @author Hugo Ferreira da Silva
  * @link http://www.hufersil.com.br
  **/
 public static function validate(Lumine_Base $obj)
 {
     $fieldList = !empty(self::$validateList[$obj->_getName()]) ? self::$validateList[$obj->_getName()] : array();
     $errors = array();
     foreach ($fieldList as $fieldName => $validators) {
         // se ja houver um erro para o campo atual
         if (self::checkStackError($errors, $fieldName) == true) {
             // passa para o proximo campo
             continue;
         }
         foreach ($validators as $array) {
             // se ja houver um erro para o campo atual
             if (self::checkStackError($errors, $fieldName) == true) {
                 // passa para o proximo campo
                 break;
             }
             switch ($array["tipoValidacao"]) {
                 //Verifica se e String
                 case 'requiredString':
                     if (!is_string($obj->{$array}["campo"]) || strlen($obj->{$array}["campo"]) == 0) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     if (isset($array["minimo"]) && strlen($obj->{$array}['campo']) < $array['minimo']) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     // se foi informado o tamanho maximo
                     if (isset($array['maximo'])) {
                         // pega o campo
                         $field = $obj->_getField($fieldName);
                         // se o tamanho informado for maior que o comprimento
                         if (isset($field['length']) && $array['maximo'] > $field['length']) {
                             throw new Lumine_Exception('Tamanho invalido para o campo ' . $fieldName, Lumine_Exception::WARNING);
                         }
                         // alterado para se o usuario
                         // informou um tamanho minimo, mas nao o maximo,
                         // o maximo passa a ser o do campo
                     } else {
                         if (!isset($array['maximo']) && isset($array['minimo'])) {
                             $field = $obj->_getField($fieldName);
                             if (isset($field['length'])) {
                                 $array['maximo'] = $field['length'];
                             }
                         }
                     }
                     if (isset($array["maximo"]) && strlen($obj->{$array}['campo']) > $array['maximo']) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     break;
                     //Verifica se e Numero
                 //Verifica se e Numero
                 case 'requiredNumber':
                     if (!is_numeric($obj->{$array}["campo"])) {
                         self::stackError($errors, $fieldName, $array['message']);
                     } else {
                         if (is_numeric($obj->{$array}['campo'])) {
                             if (!is_null($array['minimo']) && $obj->{$array}['campo'] < $array['minimo']) {
                                 self::stackError($errors, $fieldName, $array['message']);
                             } else {
                                 if (!is_null($array['maximo']) && $obj->{$array}['campo'] > $array['maximo']) {
                                     self::stackError($errors, $fieldName, $array['message']);
                                 }
                             }
                         }
                     }
                     break;
                     //Verifica se Tamanho invalido
                 //Verifica se Tamanho invalido
                 case 'requiredLength':
                     if (isset($array["minimo"])) {
                         if (strlen($obj->{$array}["campo"]) < $array["minimo"]) {
                             self::stackError($errors, $fieldName, $array['message']);
                         }
                     }
                     if (isset($array["maximo"])) {
                         if (strlen($obj->{$array}["campo"]) > $array["maximo"]) {
                             self::stackError($errors, $fieldName, $array['message']);
                         }
                     }
                     break;
                     //Verifica se e email
                 //Verifica se e email
                 case 'requiredEmail':
                     //Lumine_Util::validateEmail( $val );
                     $res = Lumine_Util::validateEmail($obj->{$array}["campo"]);
                     if ($res === false) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     break;
                     //Verifica se e uma data
                 //Verifica se e uma data
                 case 'requiredDate':
                     $val = $obj->{$array}["campo"];
                     if (!preg_match('@^((\\d{2}\\/\\d{2}\\/\\d{4})|(\\d{4}-\\d{2}-\\d{2}))$@', $val, $reg)) {
                         self::stackError($errors, $fieldName, $array['message']);
                         // se digitou no formato com barras
                     } else {
                         if (!empty($reg[2])) {
                             list($dia, $mes, $ano) = explode('/', $reg[2]);
                             // se nao for formato brasileiro e norte-americano
                             if (!checkdate($mes, $dia, $ano) && !checkdate($dia, $mes, $ano)) {
                                 self::stackError($errors, $fieldName, $array['message']);
                             }
                             // se digitou no formato ISO
                         } else {
                             if (!empty($reg[3])) {
                                 list($ano, $mes, $dia) = explode('-', $reg[3]);
                                 // se for uma data valida
                                 if (!checkdate($mes, $dia, $ano)) {
                                     self::stackError($errors, $fieldName, $array['message']);
                                 }
                             }
                         }
                     }
                     break;
                     //Verifica se e uma data/hora
                 //Verifica se e uma data/hora
                 case 'requiredDateTime':
                     $val = $obj->{$array}["campo"];
                     if (!preg_match('@^((\\d{2}\\/\\d{2}\\/\\d{4})|(\\d{4}-\\d{2}-\\d{2})) (\\d{2}:\\d{2}(:\\d{2})?)$@', $val, $reg)) {
                         self::stackError($errors, $fieldName, $array['message']);
                         // se digitou no formato com barras
                     } else {
                         if (!empty($reg[2])) {
                             list($dia, $mes, $ano) = explode('/', $reg[2]);
                             // se nao for formato brasileiro e norte-americano
                             if (!checkdate($mes, $dia, $ano) && !checkdate($dia, $mes, $ano)) {
                                 self::stackError($errors, $fieldName, $array['message']);
                             }
                             // se digitou no formato ISO
                         } else {
                             if (!empty($reg[3])) {
                                 list($ano, $mes, $dia) = explode('-', $reg[3]);
                                 // se for uma data valida
                                 if (!checkdate($mes, $dia, $ano)) {
                                     self::stackError($errors, $fieldName, $array['message']);
                                 }
                             }
                         }
                     }
                     break;
                     //Verifica uniquidade
                     // - Alteracao por Hugo: Aqui fiz uma mudanca, porque
                     //   se fosse feita um update, daria erro. por isso, checamos as chaves primarias
                 //Verifica uniquidade
                 // - Alteracao por Hugo: Aqui fiz uma mudanca, porque
                 //   se fosse feita um update, daria erro. por isso, checamos as chaves primarias
                 case 'requiredUnique':
                     $reflection = new ReflectionClass($obj->_getName());
                     $objeto = $reflection->newInstance();
                     $objeto->{$fieldName} = $obj->{$fieldName};
                     $objeto->find();
                     $todas = true;
                     while ($objeto->fetch()) {
                         $pks = $objeto->_getPrimaryKeys();
                         foreach ($pks as $def) {
                             if ($objeto->{$def}['name'] != $obj->{$def}['name']) {
                                 $todas = false;
                                 self::stackError($errors, $fieldName, $array['message']);
                                 break;
                             }
                             if ($todas == false) {
                                 break;
                             }
                         }
                     }
                     unset($objeto, $reflection);
                     break;
                     //Verifica uma funcao
                 //Verifica uma funcao
                 case 'requiredFunction':
                     // se for um array
                     if (is_array($array['message'])) {
                         $result = call_user_func_array($array['message'], array($obj, $fieldName, $obj->{$fieldName}));
                         if ($result !== true) {
                             self::stackError($errors, $fieldName, $result);
                             break;
                         }
                     }
                     if (is_string($array['message'])) {
                         $function = new ReflectionFunction($array['message']);
                         $result = $function->invoke($obj, $fieldName, $obj->{$fieldName});
                         if ($result !== true) {
                             //$errors[] = $result;
                             self::stackError($errors, $fieldName, $result);
                         }
                         unset($function);
                     }
                     break;
                     //Verifica se e CPF
                 //Verifica se e CPF
                 case 'requiredCpf':
                     $res = ValidateCPF::execute($obj->{$array}["campo"]);
                     if ($res === false) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     break;
                     //Verifica se e CNPJ
                 //Verifica se e CNPJ
                 case 'requiredCnpj':
                     $res = ValidateCNPJ::execute($obj->{$array}["campo"]);
                     if ($res === false) {
                         self::stackError($errors, $fieldName, $array['message']);
                     }
                     break;
                 default:
                     return true;
                     break;
             }
         }
     }
     return $errors;
 }
Example #2
0
 /**
  * Efetua a validacao
  * 
  * @author Hugo Ferreira da Silva
  * @link http://www.hufersil.com.br/
  * @param Lumine_Base $obj Objeto a ser validado
  * @return array Array contendo os erros encontrados
  */
 public function doValidation()
 {
     // nao possui arquivo XML para validacao, sempre retorna true
     if (empty($this->xml)) {
         return true;
     }
     $xml = new DomDocument();
     $xml->validateOnParse = true;
     $xml->load($this->xml);
     $errors = libxml_get_errors();
     libxml_clear_errors();
     if (!empty($errors)) {
         Lumine_Log::error('A validacao de "' . $this->obj->_getName() . '" nao pode ser executada por erros na formacao do XML. Analise o retorno do metodo "validate" para ver os erros');
         foreach ($errors as $error) {
             $this->errors[] = trim($error->message);
         }
         return false;
     }
     // ok, o XML nao contem erros
     // vamos pegar os campos da validacao
     $xpath = new DOMXPath($xml);
     $DOMFieldList = $xpath->query('//lumine-validator/field');
     $errors = array();
     foreach ($DOMFieldList as $DOMField) {
         // verifica se o campo existe
         try {
             $field = $this->obj->_getField($DOMField->getAttribute('name'));
             $fieldname = $field['name'];
             // recupera a lista de validator para este campo
             $query = "//lumine-validator/field[@name='{$fieldname}']/validator";
             $DOMValidatorList = $xpath->query($query);
             // para cada validator
             foreach ($DOMValidatorList as $DOMvalidator) {
                 // se ja tiver validado o campo, houver outro validator
                 // e nao passou no anterior, passa para proximo campo
                 if (isset($errors[$fieldname]) && $errors[$fieldname] !== true) {
                     break;
                 }
                 // pega os valores dos atributos
                 $minlength = sprintf('%d', $DOMvalidator->getAttribute('minlength'));
                 $maxlength = sprintf('%d', $DOMvalidator->getAttribute('maxlength'));
                 $minvalue = $DOMvalidator->getAttribute('minvalue');
                 $maxvalue = $DOMvalidator->getAttribute('maxvalue');
                 $classname = $DOMvalidator->getAttribute('classname');
                 $msg = $DOMvalidator->getAttribute('msg');
                 $rule = $DOMvalidator->getAttribute('rule');
                 $method = $DOMvalidator->getAttribute('method');
                 $val = $this->obj->{$fieldname};
                 $res = false;
                 if (empty($classname)) {
                     $classname = $DOMvalidator->getAttribute('name');
                 }
                 if ($minvalue != '') {
                     $minvalue = (double) $minvalue;
                 } else {
                     $minvalue = null;
                 }
                 if ($maxvalue != '') {
                     $maxvalue = (double) $maxvalue;
                 } else {
                     $maxvalue = null;
                 }
                 // ve o tipo
                 switch ($DOMvalidator->getAttribute('type')) {
                     case 'requiredString':
                         $res = $this->validateRequiredString($val, $minlength, $maxlength);
                         break;
                     case 'requiredNumber':
                         $res = $this->validateRequiredNumber($val, $minvalue, $maxvalue);
                         break;
                     case 'requiredEmail':
                         $res = Lumine_Util::validateEmail($val);
                         break;
                         //Verifica se e uma data
                     //Verifica se e uma data
                     case 'requiredDate':
                         if (!preg_match('@^((\\d{2}\\/\\d{2}\\/\\d{4})|(\\d{4}-\\d{2}-\\d{2}))$@', $val, $reg)) {
                             $res = false;
                             // se digitou no formato com barras
                         } else {
                             if (!empty($reg[2])) {
                                 list($dia, $mes, $ano) = explode('/', $reg[2]);
                                 // se nao for formato brasileiro e norte-americano
                                 if (!checkdate($mes, $dia, $ano) && !checkdate($dia, $mes, $ano)) {
                                     $res = false;
                                 }
                                 // se digitou no formato ISO
                             } else {
                                 if (!empty($reg[3])) {
                                     list($ano, $mes, $dia) = explode('-', $reg[3]);
                                     // se for uma data valida
                                     if (!checkdate($mes, $dia, $ano)) {
                                         $res = false;
                                     }
                                 } else {
                                     $res = true;
                                 }
                             }
                         }
                         break;
                         //Verifica se e CPF
                     //Verifica se e CPF
                     case 'requiredCpf':
                         $res = ValidateCPF::execute($val);
                         break;
                         //Verifica se e CNPJ
                     //Verifica se e CNPJ
                     case 'requiredCnpj':
                         $res = ValidateCNPJ::execute($val);
                         break;
                     case 'unique':
                         $res = $this->validateUnique($val, $fieldname);
                         break;
                     case 'class':
                         $res = $this->validateByClass($val, $fieldname, $classname, $method);
                         break;
                     case 'rule':
                         $res = $this->validateRule($val, $rule);
                         break;
                     default:
                         throw new Lumine_Validator_Exception('Tipo de validator desconhecido: ' . $DOMValidator->getAttribute('type'));
                 }
                 if ($res === false) {
                     $errors[$fieldname] = utf8_decode($msg);
                 } else {
                     $errors[$fieldname] = $res;
                 }
             }
         } catch (Exception $e) {
             Lumine_Log::warning($e->getMessage());
         }
     }
     // depois de todas as validacoes, vamos ver se deu erro em algum campo
     $tudo_ok = true;
     foreach ($errors as $chave => $erro) {
         if ($erro !== true) {
             $tudo_ok = false;
             $this->errors = $errors;
             break;
         }
     }
     // se realmente estiver tudo ok
     if ($tudo_ok === true) {
         return array();
     } else {
         return $this->errors;
     }
 }