Source for file validacao.classe.php

Documentation is available at validacao.classe.php

  1. <?php
  2.     /**
  3.      * validacao.classe.php
  4.      * 
  5.      * Efetua a validação de diversos tipos de dados isoladamente ou em conjunto.
  6.      *
  7.      * @copyright 2008 Soomp
  8.      * @author Marcio Merlone <mmerlone@gmail.com>
  9.      * @version 1.0
  10.      * @since 22/12/2006
  11.      * @package Soomp
  12.      * 
  13.      * @todo Implementar as validações necessárias
  14.      */
  15.     /* $Id: validacao.classe.php,v 1.12 2007/05/10 19:18:22 mmerlone Exp $ */
  16.     if(!defined('INDEX') && !defined('AJAX') && !defined('SOAP')){
  17.         die('Este script nao pode ser acessado diretamente!');
  18.     }
  19.  
  20.     /**
  21.      * Valida um conjunto de dados de acordo com determinadas restrições
  22.      *
  23.      * Validação individual de dados:
  24.      * <code>
  25.      * $v = new validacao();
  26.      * if($v->email('foo@fee.org')){
  27.      *     echo 'email valido';
  28.      * }else{
  29.      *     debug($v->erros);
  30.      * }
  31.      * </code>
  32.      * 
  33.      * Validação múltipla de dados:
  34.      * <code>
  35.      * $v = new validacao(true);
  36.      * $v->email('foo@fee.org');
  37.      * $v->cpf($cpf);
  38.      * $v->valida($arrValidacao);
  39.      * if($v->valido){
  40.      *     echo 'dados validos';
  41.      * }else{
  42.      *     debug($v->erros);
  43.      * }
  44.      * </code>
  45.      */
  46.     class validacao{
  47.         /**
  48.          * @var boolean $valido Armazena se há erro nos dados ou não
  49.          *  [true|false]
  50.          */
  51.         private $valido;
  52.         /**
  53.          * @var array $erros Armazena as mensagens de erro de cada dado
  54.          */
  55.         private $erros;
  56.         /**
  57.          * @var string $strObj nome do objeto a ser instanciado
  58.          */
  59.         public $strObj;
  60.  
  61.         /**
  62.          * Construtor
  63.          */
  64.         public function __construct(){
  65.             $this->erros    = array();
  66.             $this->valido    = true;
  67.         }
  68.  
  69.         /**
  70.          * Overload de propriedades privadas
  71.          * @param string $var nome da propriedade
  72.          * @param mixed $value valor da propriedade
  73.          */
  74.         private function __set($var, $value){
  75.             $this->$var = $value;
  76.         }
  77.         
  78.         /**
  79.          * Overload de propriedades privadas
  80.          * @param string $var nome da propriedade
  81.          * @return mixed valor da propriedade
  82.          */
  83.         private function __get($var){
  84.             return $this->$var;
  85.         }
  86.  
  87.         /**
  88.          * Valida um dado de acordo com restrições definidas
  89.          * <code>
  90.          * $arrValidacao = array(array('valor' => $dado, 'minv' => 1, 'maxv' => 10));
  91.          * </code>
  92.          * 
  93.          * @param array $arrValidacao array de validação de variáveis
  94.          *  especificando restrições nos dados.
  95.          * @return boolean [true|false]
  96.          */
  97.         public function valida($var, $arrValidacao){
  98.             
  99.         }
  100.         /**
  101.          * Valida um endereço de email
  102.          * @param string Endereço de email
  103.          * @param integer Define quanto se deve validar:
  104.          *  0 - Apenas a sintaxe
  105.          *  1 - Verifica a existência do domínio consultando o DNS
  106.          *  2 - Verifica a existência da caixa postal conectando ao servidor MX
  107.          * @return boolean [true|false]
  108.          */
  109.         public function email($email, $t = CFG_USUARIO_VALIDA_EMAIL){
  110.             require_once(CFG_LOCAL_FRAMEWORK.'terceiros/email_validation.php');
  111.  
  112.             $v = new email_validation_class;
  113.             $valido = $v->ValidateEmailAddress($email);
  114.             if($valido && $t >= 1){
  115.                 $valido = $v->ValidateEmailHost($email);
  116.             }
  117.             if($valido && $t >= 2){
  118.                 $valido = $v->ValidateEmailBox($email);
  119.             }
  120.             return $this->_sum($valido, 'email');
  121.         }
  122.         
  123.         /**
  124.          * Compara duas senhas se são iguais.
  125.          * @param string $senha 
  126.          * @param string $senha_confirma 
  127.          * @return boolean [true|false]
  128.          */
  129.         public function senhas($senha, $senha_confirma){
  130.             // válido se ambas forem nulas ou iguais
  131.             $valido = ((is_null($senha) && is_null($senha_confirma)) || ($senha == $senha_confirma));
  132.             return $this->_sum($valido, 'senhas');
  133.         }
  134.  
  135.         /**
  136.          * Valida um username
  137.          * Um username deve conter apenas números e letras
  138.          * mas deve iniciar por letra e ter tamanho mínimo
  139.          * de CFG_USUARIO_MIN_LEN (config.php)
  140.          * @see CFG_USUARIO_MIN_LEN
  141.          * @param string $username username a ser validado
  142.          * @return boolean [true|false]
  143.          */
  144.         public function username($username){
  145.             $valido = $this->_regexp('[a-z][a-z0-9]*', $username, 'i');
  146.             $valido = $valido && (strlen($username) >= CFG_USUARIO_MIN_LEN );
  147.             return $this->_sum($valido, 'username');
  148.         }
  149.  
  150.         /**
  151.          * Valida uma string contra uma dada regexp.
  152.          * @param string $regexp Expressão regular contra a qual testar $string
  153.          * @param string $string Texto a casar com a regexp $regexp
  154.          * @param string $modifiers modificadores da regexp
  155.          * @link http://us2.php.net/manual/en/reference.pcre.pattern.modifiers.php
  156.          * @return boolean [true|false]
  157.          */
  158.         private function _regexp($regexp, $string, $modifiers){
  159.             return preg_match("/^$regexp$/".$modifiers, $string);
  160.         }
  161.  
  162.         /**
  163.          * Calcula o valor de $this->valido
  164.          * @param boolean $valido 
  165.          * @param string $teste nome do teste que falhou
  166.          * @return boolean $valido intocado.
  167.          */
  168.         private function _sum($valido, $teste){
  169.             $this->valido = $this->valido && $valido;
  170.             if(!$valido) $this->erros[] = array($teste);
  171.             return $valido;
  172.         }
  173.         
  174.         /**
  175.          * Verifica se um objeto a ser salvo possui o nome duplicado
  176.          * Se o pk dado for nulo trata-se de adição, caso contrário de edição.
  177.          * @param array $arrInfo array com informações para verificação de
  178.          *  duplicidade. O primeiro elemento do array deve ser o pk.
  179.          *  <code>
  180.          *  $arrInfo = array('PK_OBJ' => 1, 'NO_OBJ' => 'foo')
  181.          *  </code>
  182.          * @return boolean $duplicado true se já existe registro com o mesmo nome.
  183.          */
  184.         public function duplicado($arrInfo){
  185.  
  186.             $arrFields    = array_keys($arrInfo);
  187.             $arrData    = array_values($arrInfo);
  188.  
  189.                $obj = new $this->strObj();
  190.             $obj->Load($arrData[1]);
  191.  
  192.             if(
  193.                 /**
  194.                  * Adicionando objeto - Objeto a ser salvo não tem pk ainda mas
  195.                  * existe outro objeto no banco de dados com o mesmo nome
  196.                  */
  197.                 (empty($arrData[0]) && $obj->{$arrFields[0]}) ||
  198.                 /**
  199.                  * Editando objeto - Objeto já tem pk e o pk recuperado no load
  200.                  * é diferente do objeto em questão, poranto já existe outro com
  201.                  * o mesmo nome
  202.                  */
  203.                 (!empty($arrData[0]) && $obj->{$arrFields[0]} && $arrData[0] != $obj->{$arrFields[0]})
  204.             ){
  205.                    $valido = false;
  206.             }else{
  207.                    $valido = true;
  208.             }
  209.             return $this->_sum($valido, 'duplicado');
  210.         }
  211.     }
  212.  
  213. ?>

Documentation generated on Sun, 09 Mar 2008 23:53:44 -0300 by phpDocumentor 1.4.0

SourceForge.net Logo Support This Project