API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 11th, 2010
509
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 23.08 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2. /**
  3.  * Classe para filtrar os inputs vindos das variáveis superglobais.<br />
  4.  * Mascara e simplifica os filtros padrões do PHP, expandindo para as opções comuns utilizadas no site,
  5.  * como celular, cep, cidades, etc.<br />
  6.  * <br />
  7.  *
  8.  * <b>-= Instruções para adicionar novos filtros =-</b>
  9.  * 1. criar uma constante TIPO_
  10.  * 2. editar os switches dos métodos validar() e limpar() conforme necessário
  11.  * 3. criar métodos validar_() e limpar_() conforme necessário
  12.  */
  13. class Filtrar {
  14.  
  15.     /** Constante para filtrar $_POST */    const POST  = INPUT_POST;
  16.     /** Constante para filtrar $_GET */ const GET   = INPUT_GET;
  17.     /** Constante para filtrar $_COOKIE */  const COOKIE    = INPUT_COOKIE;
  18.     /** Constante para filtrar $_SERVER */  const SERVER    = INPUT_SERVER;
  19.     /** Constante para filtrar $_ENV */ const ENV   = INPUT_ENV;
  20.     /** Constante para filtrar variáveis */    const VARIAVEL  = 'var';
  21.  
  22.     /** Constante para filtrar strings */           const TIPO_STRING   = 's';
  23.     /** Constante para filtrar números inteiros */     const TIPO_INTEIRO  = 'i';
  24.     /** Constante para filtrar números decimais */     const TIPO_DECIMAL  = 'd';
  25.     /** Constante para filtrar a partir de ExpReg */    const TIPO_REGEXP   = 'r';
  26.     /** Constante para filtrar datas (DD/MM/AAAA) */    const TIPO_DATA     = 'D';
  27.     /** Constante para filtrar horários */         const TIPO_HORA     = 'H';
  28.     /** Constante para filtrar data e hora juntos */    const TIPO_DATAHORA = 'DH';
  29.     /** Constante para filtrar telefone com DDD */      const TIPO_TELEFONE = 'T';
  30.     /** Constante para filtrar CEPs */          const TIPO_CEP      = 'C';
  31.     /** Constante para filtrar e-mails */           const TIPO_EMAIL    = 'E';
  32.     /** Constante para filtrar URLs */          const TIPO_URL      = 'U';
  33.     /** Constante para filtrar IPs */           const TIPO_IP       = 'I';
  34.  
  35.     /** Constante exclusiva de validação de booleanos */      const VALIDA_BOOL   = 'b';
  36.     /** Constante exclusiva de validação cidade (id_cidade) */    const VALIDA_CIDADE = 'CD';
  37.     /** Constante exclusiva de validação estado (id_estado) */    const VALIDA_ESTADO = 'ES';
  38.     /** Constante exclusiva de validação país (id_pais) */       const VALIDA_PAIS   = 'PA';
  39.  
  40.     /** Constante exclusiva de limpeza de strings encodadas para URL */ const LIMPA_URL_ENCODED     = 'UE';
  41.     /** Constante exclusiva de limpeza de caracteres especiais */       const LIMPA_CARAC_HTML      = 'CE';
  42.     /** Constante exclusiva de limpezade caracteres especiais */        const LIMPA_PERSONALIZADO   = 'G';
  43.  
  44.     /**
  45.      * Limite inferior para o ano, na validação da data
  46.      * @var integer */ const ANO_MIN = 1900;
  47.  
  48.     /**
  49.      * Qual será o grupo a filtrar (se vai filtrar uma variável diretamente ou um input vindo de uma superglobal).
  50.      * Aceita somente as constantes da classe.
  51.      * @var const */ protected $grupo;
  52.  
  53.     /**
  54.      * O nome da variável superglobal a ser filtrada.</br >
  55.      * Se estiver usando o grupo VARIAVEL, isso aqui conterá NULL
  56.      * @var string */ protected $variavel = null;
  57.  
  58.     /**
  59.      * Se true, irá imprimir ao término da classe os filtros que rodaram
  60.      * @var boolean */ public $debug = false;
  61.  
  62.     /**
  63.      * Contém o output de debug
  64.      * @var string */ protected $output_debug = '';
  65.  
  66. /* --------------- construtores e afins genéricos --------------- */
  67.  
  68.     public function __construct($grupo = self::VARIAVEL) {
  69.         $this->set_grupo($grupo);
  70.     }
  71.  
  72.     /** @return Filtrar */  public static function POST()       { return new Filtrar(self::POST);   }
  73.     /** @return Filtrar */  public static function GET()        { return new Filtrar(self::GET);    }
  74.     /** @return Filtrar */  public static function COOKIE()     { return new Filtrar(self::COOKIE); }
  75.     /** @return Filtrar */  public static function SERVER()     { return new Filtrar(self::SERVER); }
  76.     /** @return Filtrar */  public static function ENV()        { return new Filtrar(self::ENV);    }
  77.     /** @return Filtrar */  public static function VARIAVEL()   { return new Filtrar(self::VARIAVEL);   }
  78.  
  79.     public function  __destruct() {
  80.         if ($this->debug) echo '<pre>',$this->output_debug,'</pre>';
  81.     }
  82.  
  83.     /**
  84.      * Setter para {@link $tipo}. Só aceita como argumento as constantes da classe.
  85.      * @param const $novo_grupo
  86.      */
  87.     public function set_grupo($novo_grupo) {
  88.         if (!in_array($novo_grupo, array(self::POST, self::GET, self::COOKIE, self::SERVER, self::ENV, self::VARIAVEL)))
  89.             throw new InvalidFilterException();
  90.         else {
  91.             $this->grupo = $novo_grupo;
  92.             switch ($novo_grupo) {
  93.                 case self::POST:        $this->variavel =& $_POST;  break;
  94.                 case self::GET:         $this->variavel =& $_GET;   break;
  95.                 case self::COOKIE:      $this->variavel =& $_COOKIE;    break;
  96.                 case self::SERVER:      $this->variavel =& $_SERVER;    break;
  97.                 case self::ENV:         $this->variavel =& $_ENV;   break;
  98.                 case self::VARIAVEL:        $this->variavel = null;     break;
  99.             }
  100.         }
  101.     }
  102.  
  103.     /**
  104.      * Mascara as funções filter_var() e filter_input() num método só
  105.      * @param string $var
  106.      * @param string $filtro
  107.      * @param array $opcoes
  108.      */
  109.     protected function filtra_grupo($var, $filtro, array $opcoes = null) {
  110.         if ($this->grupo == self::VARIAVEL) {
  111.             if ($this->debug) $this->output_debug .= 'filter_var("'.$var.'", "'.$filtro.', '.strtr(var_export($opcoes, true), array("\n" => '', "  " => '', '\\\\' => '\\')).")\n";
  112.             return filter_var($var, $filtro, $opcoes);
  113.         }
  114.         else {
  115.             if ($this->debug) $this->output_debug .= 'filter_input('.$this->grupo.', "'.$var.'", '.$filtro.', '.strtr(var_export($opcoes, true), array("\n" => '', "  " => '', '\\\\' => '\\')).")\n";
  116.             return filter_input($this->grupo, $var, $filtro, $opcoes);
  117.         }
  118.     }
  119.  
  120.  
  121. /* --------------- validadores --------------- */
  122.  
  123.     /**
  124.      * Diz se um valor é válido ou não, de acordo com o tipo.<br />
  125.      * Valida o formato do valor, e depois chama {@link pos_validacao}, que valida o valor propriamente dito.
  126.      *
  127.      * @param const $tipo uma constante da classe, TIPO_*
  128.      * @param string $var o nome do campo/variável a testar
  129.      * @param array $opcoes array de opções para o filtro em questão; flags devem estar juntas (flag | flag) no
  130.      * @return boolean
  131.      */
  132.     protected function validar($tipo, $var, array $opcoes = null) {
  133.         switch ($tipo) {
  134.             case self::TIPO_STRING  : $filtrado = $this->filtra_grupo($var, FILTER_UNSAFE_RAW);         break;
  135.             case self::TIPO_INTEIRO : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_INT, $opcoes);      break;
  136.             case self::TIPO_DECIMAL : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_FLOAT, $opcoes);    break;
  137.             case self::TIPO_EMAIL   : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_EMAIL);         break;
  138.             case self::TIPO_URL : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_URL, $opcoes);      break;
  139.             case self::TIPO_IP  : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_IP, $opcoes);       break;
  140.             case self::VALIDA_BOOL  : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_BOOLEAN, array('flags' => FILTER_NULL_ON_FAILURE)); break;
  141.            
  142.             case self::TIPO_DATA    : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => '/^\d{2}\/\d{2}\/\d{4}$/', $var)));                    break;
  143.             case self::TIPO_HORA    : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => '/^\d{2}:\d{2}(\:\d{2})?$/', $var)));                  break;
  144.             case self::TIPO_DATAHORA: $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => '/^\d{2}\/\d{2}\/\d{4} \d{2}:\d{2}(\:\d{2})?$/')));    break;
  145.             case self::TIPO_TELEFONE: $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => '/^\(\d{2}\)\s\d{4}[-\.\s]{0,1}\d{4}$/')));            break;
  146.             case self::TIPO_CEP     : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => '/^\d{5}-\d{3}$/', $var)));                            break;
  147.             case self::TIPO_REGEXP  : $filtrado = $this->filtra_grupo($var, FILTER_VALIDATE_REGEXP, array('options' => array('regexp' => $opcoes['regexp'], $var)));                            break;
  148.  
  149.             case self::VALIDA_CIDADE: $classe = 'Cidade';
  150.             case self::VALIDA_ESTADO: if (!isset($classe)) $classe = 'Estado';
  151.             case self::VALIDA_PAIS  : if (!isset($classe)) $classe = 'Pais';
  152.                 $obj = new $classe($this->variavel[$var], false);
  153.                 $filtrado = $obj->nome;
  154.                 unset($obj);
  155.             break;
  156.  
  157.             case self::LIMPA_CARAC_HTML     :
  158.             case self::LIMPA_PERSONALIZADO  :
  159.             case self::LIMPA_URL_ENCODED    : throw new InvalidFilterException('Tipo de operação incorreta! '.$tipo, InvalidFilterException::OPCAO_INVALIDA); break;
  160.         }
  161.  
  162.         return $this->pos_validacao($tipo, $filtrado, $opcoes, $var);
  163.     }
  164.  
  165.     protected function pos_validacao($tipo, $valor_filtrado, $opcoes, $var) {
  166.         switch ($tipo) {
  167.             case self::TIPO_STRING : return (bool)strlen($valor_filtrado); break;
  168.            
  169.             case self::VALIDA_BOOL :
  170.                 if (is_null($valor_filtrado) && strlen($this->variavel[$var]) === 0) return true;
  171.                 else return is_bool($valor_filtrado);
  172.             break;
  173.  
  174.             case self::TIPO_INTEIRO :
  175.                 if ($opcoes['flags'] & FILTER_FLAG_ALLOW_OCTAL) $octal  = $valor_filtrado === octdec($this->variavel[$var]);
  176.                 if ($opcoes['flags'] & FILTER_FLAG_ALLOW_HEX)   $hex    = $valor_filtrado === hexdec($this->variavel[$var]);
  177.                 $int = $valor_filtrado === (int)$this->variavel[$var];
  178.                 return $int || $hex || $octal;
  179.             break;
  180.  
  181.             case self::TIPO_DECIMAL :
  182.                     if ($opcoes['flags'] & FILTER_FLAG_ALLOW_THOUSAND) return $valor_filtrado === (float)str_replace(',', '', $this->variavel[$var]);
  183.                     else return $valor_filtrado === (float)$this->variavel[$var];
  184.             break;
  185.  
  186.             case self::TIPO_DATA    : return $this->validacao_numerica_data($valor_filtrado);   break;
  187.             case self::TIPO_HORA    : return $this->validacao_numerica_hora($valor_filtrado);   break;
  188.             case self::TIPO_DATAHORA: return $this->validacao_numerica_data(strtok($valor_filtrado, ' ')) && $this->validacao_numerica_hora(strtok(' ')); break;
  189.  
  190.             case self::VALIDA_CIDADE:
  191.             case self::VALIDA_ESTADO:
  192.             case self::VALIDA_PAIS  : return !is_null($valor_filtrado); break;
  193.            
  194.             default                 : return $valor_filtrado === $this->variavel[$var];         break;
  195.         }
  196.     }
  197.  
  198.     /**
  199.      * Recebe uma data no formato DD/MM/AAAA e retorna se o valor é válido ou não.<br />
  200.      * É diferente da primeira validação porque aqui verificamos se não é um dia ou ano absurdo.
  201.      * Na primeira é verificado somente o formato.
  202.      * @param string $data
  203.      * @return boolean
  204.      */
  205.     protected function validacao_numerica_data($data) {
  206.         $d = strtok($data, '/'); $m = strtok('/'); $a = strtok('/');
  207.         if ($a < self::ANO_MIN) return false;
  208.         else return checkdate($m, $d, $a);
  209.     }
  210.  
  211.     /**
  212.      * Valida um horário no formato HH:MM[:SS], verificando não o formato, mas se é uma hora de verdade.<br />
  213.      * Aceita intervalos entre 00:00:00 e 23:59:59.
  214.      * @param string $hora
  215.      * @return boolean
  216.      */
  217.     protected function validacao_numerica_hora($hora) {
  218.         $h = strtok($hora, ':'); $m = strtok(':'); $s = strtok(':');
  219.         return (($h >= 0 && $h <= 23) &&
  220.                 ($m >= 0 && $m <= 59) &&
  221.                 (is_null($s) || ($s >= 0 && $s <= 59))
  222.         );
  223.     }
  224.  
  225.     /* ----- métodos com opções ----- */
  226.  
  227.     /**
  228.      * Valida números inteiros.<br />
  229.      * Atenção: -10 é um inteiro, mas +0 ou -0 só são considerados válidos como decimais.
  230.      * @param boolean $octal se permite valores octais, que começam com 0 (ex: 0563)
  231.      * @param boolean $hex se permite valores hexadecimais, que começam com 0x (ex: 0xFA8)
  232.      * @param boolean $min_range número mínimo, inclusive
  233.      * @param boolean $max_range número máximo, inclusive
  234.      * @return boolean
  235.      */
  236.     public function validar_inteiro($var, $octal = false, $hex = false, $min_range = null, $max_range = null) {
  237.         $opcoes = array('flags' => 0);
  238.         if ($octal)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_OCTAL;
  239.         if ($hex)       $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_HEX;
  240.         if ($min_range) $opcoes['options']['min_range'] = $min_range;
  241.         if ($max_range) $opcoes['options']['max_range'] = $max_range;
  242.  
  243.         return $this->validar(self::TIPO_INTEIRO, $var, $opcoes);
  244.     }
  245.  
  246.     /**
  247.      * Valida decimais.
  248.      * @param boolean $separador_milhar se pode usar uma vírgula para separar os milhares
  249.      * @return boolean */
  250.     public function validar_decimal($var, $separador_milhar = false) {
  251.         $opcoes = array('flags' => 0);
  252.         if ($separador_milhar) $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_THOUSAND;
  253.  
  254.         return $this->validar(self::TIPO_DECIMAL, $var, $opcoes);
  255.     }
  256.  
  257.     /**
  258.      * Valida URLs. Devem, obrigatoriamente, possuir o protocolo.
  259.      * @param boolean $path se é obrigatório um path após o endereço do site
  260.      * @param boolean $query se é obrigatório o uso de uma querystring
  261.      * @return boolean
  262.      */
  263.     public function validar_url($var, $path = false, $query = false) {
  264.         $opcoes = array('flags' => 0);
  265.         if ($path)  $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_PATH_REQUIRED;
  266.         if ($query) $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_QUERY_REQUIRED;
  267.  
  268.         return $this->validar(self::TIPO_URL, $var, $opcoes);
  269.     }
  270.  
  271.     /**
  272.      * Valida um IP.
  273.      * @param integer $ipv Se validará somente IPV4 [4], IPV6 [6], ou os dois [null]
  274.      * @param boolean $private_range Se permitirá IPs privados
  275.      * @param boolean $reserved_range Se permitirá IPs reservados
  276.      * @return boolean
  277.      */
  278.     public function validar_ip($var, $ipv = null, $private_range = false, $reserved_range = false) {
  279.         $opcoes = array('flags' => 0);
  280.         if      ($ipv == 4)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_IPV4;
  281.         elseif  ($ipv == 6)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_IPV6;
  282.         elseif  ($ipv !== null) throw new InvalidFilterException('Tentativa de filtrar IPV'.$ipv.'. As opções válidas são IPV4, IPV6, ou NULL (filtra pelos dois).', 1);
  283.  
  284.         if (!$private_range)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_NO_PRIV_RANGE;
  285.         if (!$reserved_range)   $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_NO_RES_RANGE;
  286.  
  287.         return $this->validar(self::TIPO_IP, $var, $opcoes);
  288.     }
  289.  
  290.     public function validar_regexp($var, $regexp) {
  291.         return $this->validar(self::TIPO_REGEXP, $var, array('options' => array('regexp' => $regexp)));
  292.     }
  293.  
  294.     /* ----- métodos sem opções ----- */
  295.     /**
  296.      * Valida, basicamente, nada. Verifica se a string tem mais de um caracter.
  297.      * @return boolean */
  298.     public function validar_string($var) { return $this->validar(self::TIPO_STRING, $var); }
  299.    
  300.     /**
  301.      * Valida telefon ou celular.<br />Aceita o formato (88) 8888-8888
  302.      * @return boolean */
  303.     public function validar_booleano($var) { return $this->validar(self::VALIDA_BOOL, $var); }
  304.    
  305.     /**
  306.      * Aceita o formato (88) 8888-8888
  307.      * @return boolean */
  308.     public function validar_email($var) { return $this->validar(self::TIPO_EMAIL, $var); }
  309.    
  310.     /**
  311.      * Valida data.<br />Aceita o formato DD/MM/AAAA
  312.      * @return boolean */
  313.     public function validar_data($var) { return $this->validar(self::TIPO_DATA, $var); }
  314.    
  315.     /**
  316.      * Valida hora.<br />Aceita o formato HH:MM[:SS]
  317.      * @return boolean */
  318.     public function validar_hora($var) { return $this->validar(self::TIPO_HORA, $var); }
  319.    
  320.     /**
  321.      * Valida data e hora, juntos.<br />Aceita o formato DD/MM/AAAA HH:MM[:SS]
  322.      * @return boolean */
  323.     public function validar_data_hora($var) { return $this->validar(self::TIPO_DATAHORA, $var); }
  324.    
  325.     /**
  326.      * Valida telefone ou celular.<br />Aceita o formato (88) 8888-8888
  327.      * @return boolean */
  328.     public function validar_telefone($var) { return $this->validar(self::TIPO_TELEFONE, $var); }
  329.  
  330.     /**
  331.      * Valida CEP.<br />Aceita o formato 88888-888
  332.      * @return boolean */
  333.     public function validar_cep($var) { return $this->validar(self::TIPO_CEP, $var); }
  334.  
  335.     /**
  336.      * Valida id_cidade.
  337.      * @return boolean */
  338.     public function validar_cidade($var) { return $this->validar(self::VALIDA_CIDADE, $var); }
  339.  
  340.     /**
  341.      * Valida id_estado.
  342.      * @return boolean */
  343.     public function validar_estado($var) { return $this->validar(self::VALIDA_ESTADO, $var); }
  344.  
  345.     /**
  346.      * Valida id_pais.
  347.      * @return boolean */
  348.     public function validar_pais($var) { return $this->validar(self::VALIDA_PAIS, $var); }
  349.    
  350.     /* ----- aliases ----- */
  351.     /**
  352.      * Valida decimais. Alias de {@link validar_decimal}.
  353.      * @param boolean $separador_milhar se pode usar uma vírgula para separar os milhares
  354.      * @return boolean */
  355.     public function validar_float($var, $separador_milhar = false) { return $this->validar_decimal($var, $separador_milhar); }
  356.  
  357.     /**
  358.      * Valida celular e telefone. Alias de {@link validar_telefone}.<br />Aceita o formato (88) 8888-8888
  359.      * @return boolean */
  360.     public function validar_celular($var) { return $this->validar_telefone($var); }
  361.  
  362.  
  363. /* --------------- sanitizadores --------------- */
  364.    
  365.     /**
  366.      * Retorna o valor sanitizado da variável
  367.      * @param const $tipo uma constante da classe, TIPO_*
  368.      * @param string $var o nome do campo/variável a testar
  369.      * @return string
  370.      */
  371.     protected function limpar($tipo, $var, array $opcoes = null) {
  372.         switch ($tipo) {
  373.             case self::TIPO_STRING  : return $this->filtra_grupo($var, FILTER_SANITIZE_STRING, $opcoes);        break;
  374.             case self::TIPO_INTEIRO : return $this->filtra_grupo($var, FILTER_SANITIZE_NUMBER_INT);             break;
  375.             case self::TIPO_DECIMAL : return $this->filtra_grupo($var, FILTER_SANITIZE_NUMBER_FLOAT, $opcoes);  break;
  376.             case self::TIPO_EMAIL   : return $this->filtra_grupo($var, FILTER_SANITIZE_EMAIL);                  break;
  377.             case self::TIPO_URL     : return $this->filtra_grupo($var, FILTER_SANITIZE_URL);                    break;
  378.  
  379.             case self::LIMPA_URL_ENCODED    : return $this->filtra_grupo($var, FILTER_SANITIZE_ENCODED);                break;
  380.             case self::LIMPA_PERSONALIZADO  : return $this->filtra_grupo($var, FILTER_UNSAFE_RAW, $opcoes);             break;
  381.             case self::LIMPA_CARAC_HTML     : return $this->filtra_grupo($var, FILTER_SANITIZE_SPECIAL_CHARS, $opcoes); break;
  382.  
  383.            
  384.             case self::TIPO_DATA    :
  385.             case self::TIPO_HORA    :
  386.             case self::TIPO_DATAHORA:
  387.             case self::TIPO_TELEFONE:
  388.             case self::TIPO_CEP     : //para habilitar sanitização para essas constantes TIPO_* aqui,
  389.             case self::TIPO_IP      : //é necessário usar algum tipo de substituição por expressões regulares... por enquanto não.
  390.             case self::TIPO_REGEXP  : throw new InvalidFilterException('Tipo de operação incorreta! '.$tipo, InvalidFilterException::NAO_IMPLEMENTADO); break;
  391.  
  392.             case self::VALIDA_BOOL  :
  393.             case self::VALIDA_CIDADE:
  394.             case self::VALIDA_ESTADO:
  395.             case self::VALIDA_PAIS  : throw new InvalidFilterException('Tipo de operação incorreta! '.$tipo, InvalidFilterException::OPCAO_INVALIDA); break;
  396.         }
  397.     }
  398.  
  399.     /* ----- métodos com opções ----- */
  400.  
  401.     /**
  402.      * Limpa tags HTML. Opcionalmente, também pode encodar aspas.<br />
  403.      * Para limpar outras famílias de caracteres, use {@link limpar_personalizado}
  404.      * @param string $var
  405.      * @param boolean $encoda_aspas se aspas serão encodadas também
  406.      * @return string
  407.      */
  408.     public function limpar_string($var, $encoda_aspas = true) {
  409.         $opcoes = array('flags' => 0);
  410.         if (!$encoda_aspas) $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_NO_ENCODE_QUOTES;
  411.  
  412.         return $this->limpar(self::TIPO_STRING, $var, $opcoes);
  413.     }
  414.  
  415.     /**
  416.      * Limpa números de ponto flutuante. Permite opcionalmente pontos, vírgulas e sinais para números científicos.
  417.      * @param string $var
  418.      * @param boolean $milhar permite vírgulas para separar os milhares
  419.      * @param boolean $fracional permite ponto para números decimais
  420.      * @param boolean $cientifico permite "e" ou "E" para indicar números científicos
  421.      * @return string
  422.      */
  423.     public function limpar_float($var, $milhar = false, $fracional = false, $cientifico = false) {
  424.         $opcoes = array('flags' => 0);
  425.         if ($milhar)        $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_THOUSAND;
  426.         if ($fracional)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_FRACTION;
  427.         if ($cientifico)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ALLOW_SCIENTIFIC;
  428.  
  429.         return $this->limpar(self::TIPO_DECIMAL, $var, $opcoes);
  430.     }
  431.  
  432.     /**
  433.      * Escapa aspas, &lt; &gt;, & e caracteres com valor numérico menor que 32, transformando HTML em texto legível.<br />
  434.      * Opcionalmente pode retirar os caracteres menores que 32 e maiores que 127, e transformar outros caracteres em entidades HTML.
  435.      * @param string $var
  436.      * @param boolean $entidades encoda os caracteres de valor numérico acima de 127 (como caracteres acentuados e adiante)
  437.      * @param boolean $strip_low retira os caracteres de valor numérico abaixo de 32 (como caracteres de marcação, quebra de linha, etc)
  438.      * @param boolean $strip_high retira os caracteres de valor numérico acima de 127 (como caracteres acentuados e adiante)
  439.      * @return string
  440.      */
  441.     public function limpar_caracteres_html($var, $entidades = true, $strip_low = false, $strip_high = false) {
  442.         $opcoes = array('flags' => 0);
  443.         if ($entidades)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ENCODE_HIGH;
  444.         if ($strip_low)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_STRIP_LOW;
  445.         if ($strip_high)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_STRIP_HIGH;
  446.        
  447.         return $this->limpar(self::LIMPA_CARAC_HTML, $var, $opcoes);
  448.     }
  449.  
  450.     /**
  451.      * Não limpa nada por si só. Serve para efetuar operações de sanitização de acordo com os argumentos fornecidos.
  452.      * @param string $var
  453.      * @param boolean $strip_low retira os caracteres de valor numérico abaixo de 32 (como caracteres de marcação, quebra de linha, etc)
  454.      * @param boolean $strip_high retira os caracteres de valor numérico acima de 127 (como caracteres acentuados e adiante)
  455.      * @param boolean $encode_low encoda os caracteres de valor numérico abaixo de 32 (como caracteres de marcação, quebra de linha, etc)
  456.      * @param boolean $encode_high encoda os caracteres de valor numérico acima de 127 (como caracteres acentuados e adiante)
  457.      * @param boolean $encode_amp encoda ampersand, vulgo "E comercial" (&)
  458.      * @return string
  459.      */
  460.     public function limpar_personalizado($var, $strip_low = false, $strip_high = false, $encode_low = false, $encode_high = false, $encode_amp = false) {
  461.         $opcoes = array('flags' => 0);
  462.         if ($strip_low)     $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_STRIP_LOW;
  463.         if ($strip_high)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_STRIP_HIGH;
  464.         if ($encode_low)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ENCODE_LOW;
  465.         if ($encode_high)   $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ENCODE_HIGH;
  466.         if ($encode_amp)    $opcoes['flags'] = $opcoes['flags'] | FILTER_FLAG_ENCODE_AMP;
  467.  
  468.         return $this->limpar(self::LIMPA_PERSONALIZADO, $var, $opcoes);
  469.     }
  470.  
  471.     /* ----- métodos sem opções ----- */
  472.     public function limpar_inteiro($var)        { return $this->limpar(self::TIPO_INTEIRO, $var); }
  473.     public function limpar_email($var)          { return $this->limpar(self::TIPO_EMAIL, $var); }
  474.     public function limpar_url($var)            { return $this->limpar(self::TIPO_URL, $var); }
  475.     public function limpar_url_encoded($var)    { return $this->limpar(self::LIMPA_URL_ENCODED, $var); }
  476.  
  477.     /* ----- aliases ----- */
  478.     public function limpar_html($var, $encoda_aspas = true) { return $this->limpar_string($var, $encoda_aspas); }
  479.     public function limpar_decimal($var, $milhar = false, $fracional = true, $cientifico = false) { return $this->limpar_float($var, $milhar, $fracional, $cientifico); }
  480. }
  481.  
  482. /**
  483.  * Possíveis códigos de erro:
  484.  * 0 - erro desconhecido
  485.  * 1 - opção inválida
  486.  * 2 - não implementado
  487.  */
  488. class InvalidFilterException extends Exception {
  489.     const DESCONHECIDO      = 0;
  490.     const OPCAO_INVALIDA    = 1;
  491.     const NAO_IMPLEMENTADO  = 2;
  492.  
  493.     public function  __construct($message = '', $code = 0, $previous = null) {
  494.         parent::__construct($message, $code, $previous);
  495.     }
  496. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!