Há quanto tempo pessoas!
Pois é, a vida está bastante corrida, e o tempo anda curto… quando sobra algum, a gente acaba dormindo : | Meleca viu… Mas, lamentações a parte, vamos falar sobre o que realmente interessa: PHP!
Bom, como ando meio sem criatividade para postar, decidi que vou demonstrar uma maneira de realizar validação de campos, utilizando xml para caracterizar essa validação, fazendo com que você não precise sair que nem louco caçando as validações no meio do seu código o dia que precisar alterar alguma. Esse é o tipo de validação que o E. Silva e eu temos utilizado em nosso framework do qual ele já comentou ai em alguns comentários (frase linda).
Algumas idéias aqui, poderão parecer confusas de início para quem não está muito acostumado com PHP, mas como sempre digo, se tem alguma duvida, fique a vontade para mandar email ou deixar comentário que a gente resolve como pode.
Como sempre, gosto de começar com exemplos, então, vamos começar com o XML de exemplo:
validador.xml
<validator>
<field name=‘nome’ validation=‘validator::isFilled’ when=‘insert,update’ />
<field name=‘cpf’ validation=‘validator::isCpf’ when=‘insert,update’ />
<field name=‘data’ validation=‘validator::isData’ when=‘insert’ />
</validator>
Esse ai será o xml que iremos usar para validar nossos campos. Vamos entender algumas coisas:
A propriedade ‘name’, identifica o nome do campo que será validado
A propriedade ‘validation’, define o método que será utilizado para validação
A propriedade ‘when’ define quando a validação deverá ocorrer. Essa propriedade será identificada através da ação que o botão do formulário fornece.
Os exemplos que serão trabalhados, utilizam o método POST para envio dos dados, e tem o action definido na própria página. Preparem-se, pois hoje teremos bastante código.
Vamos dar uma olhada agora, no código do formulário, que ficará no script que chamaremos de index.php
index.php
<form method=“POST”>
<input type=“text” name=“nome” /><br />
<input type=“text” name=“cpf” /><br />
<input type=“text” name=“data” /><br />
<!– agora vem o botão de submit, que identificará a ação que ocorre –>
<input type=“submit” name=“acao” value=“Insert” />
</form>
Esse script ainda não está pronto. Falta ainda o código PHP do mesmo. Agora, vou esclarecer um pouco melhor como será o funcionamento do script.
Todo o formulário, será (ou não), preenchido, e será feito o envio das informações ao se clicar no botão de Inserir. Quando o script receber esses dados, será invocada a classe, que lê o xml de validação, e aplica essa validação aos campos que foram recebidos. Os campos serão validados conforme descrição feita pelo XML, e a partir dai serão geradas as mensagens do sistema. O script que será demonstrado é um exemplo, para dar uma idéia de como se utilizar esse método de validação. Não estou demonstrando exatamente igual ao funcionamento do nosso framework, pelo simples fato, de que eu iria precisar de muitas classes do framework para isso, e então deixaria de ser um post de blog, para virar um livro : |
Veja então a classe que irá fazer o parse do arquivo xml, e validará as entradas fornecidas pelo usuário:
action.class.php
<?php
class Action {
// Essa propriedade da classe, ira conter
// o resultado da validacao de cada um dos
// campos.
private $validacao = array( );
// Essa propriedade ira dizer se ocorreu algum erro
// para o script
private $error = null;
// Retorna o valor da propriedade $error
public function getError( ) {
return $this->error;
}
// Retorna o valor da propriedade $validacao
public function getValidacao( ) {
return $this->validacao;
}
public function run( ) {
// normalmente, possuimos uma classe para trabalhar
// com metodo POST e GET. No nosso caso, de forma a
// simplificar a quantidade de codigo, vamos usar a
// variavel $_POST diretamente
// Essas aqui serao as acoes que iremos validar. Como
// ja comentado, as acoes sao definidas atraves do valor
// do botao que faz o metodo POST
$validActions = array(
'insert',
'update',
'delete'
);
$acao = strtolower( $_POST['acao'] );
if( in_array( $acao , $validActions ) ) {
// Inicializar a variavel de controle de erro
$this->error = true;
// Se chegou nesse ponto, significa que a acao realizada
// foi uma das acima. Agora deve-se carregar o xml e começar a
// fazer o seu parsing
$xml = simplexml_load_file( 'validador.xml' );
// A partir de agora, vamos avaliar cada uma das linhas do xml
// e realizar a validacao.
foreach( $xml->field as $campo ) {
// Aqui, vamos procurar pelo campo atual que encontramos no xml
// dentro do array $_POST. Se o campo for encontrado, iremos
// validar o valor que nos foi enviado.
if( array_key_exists( (string)$campo['name'], $_POST ) ) {
// Otimo, encontramos o campo no array POST. Porem antes
// de validarmos o campo, precisamos verificar se ele
// deve ser validado na acao que esta acontecendo.
// Lembra-se da propriedade 'when' no xml? Eh aqui
// que ela entra, nos informando se o campo deve ou nao
// ser validado. As acoes devem ser separadas por uma ','
// no xml
$whenToValidate = explode(',', $campo['when'] );
if( in_array( $acao, $whenToValidate ) ) {
// Finalmente chegamos! Chegou aqui, entao esta na hora
// de validar o campo de acordo com o que esta no xml.
// O conteudo especificado na propriedade 'validation'
// do xml, define um metodo estatico a ser chamado para
// validar o valor que foi enviado no metodo post
// nos permitindo assim, assumit que esse metodo recebe
// ao menos 1 parametro, que eh o valor a ser validado
// Veja a classe com os metodos de validacao, para
// entender exatamente o que acontece
$codigo = sprintf('$ret = %s( $_POST["%s"] );',
(string)$campo['validation'],
(string)$campo['name']
);
// Suponto que estamos validando o campo 'nome', que
// da maneira como está descrito no xml do tutorial,
// teremos $codigo valendo algo como:
// $ret = validator::isFilled( $_POST["nome"] );
// Executa-se o código de validação agora. A variavel
// $ret ira conter o resultado da validacao.
eval( $codigo );
// Caso $ret seja diferente de true, estou assumindo
// que o retorno é entao uma mensagem de erro
if( $ret === true ) {
$this->validacao[(string)$campo['name']] = true;
} else {
$this->error = true;
$this->validacao[(string)$campo['name']] = $ret;
}
}
}
}
}
}
}
?>
Com esse código em mãos, precisamos também ter a classe que faz validação do conteúdo digitado nos campos. Como foi denifido no xml, a classe que estamos usando é a classe Validator. A que irei apresentar, faz validações hipóteticas, não sendo recomendado o uso delas, da forma que estão. Veja o código:
validator.class.php
<?php
class Validator {
// Método que verifica se há algum valor em $valor
public static function isFilled( $valor ) {
if( empty( $valor ) )
return 'Campo nao pode ser vazio';
return true;
}
// Metodo que iria validaro valor, para saber se este
// eh um cpf valido
public static function isCpf( $valor ) {
if( $valor == '11111111111' )
return 'CPF invalido';
return true;
}
// Metodo que verificaria se a data informada
// eh valida
public static function isData( $valor ) {
$data = explode('/',$valor);
if( sizeof( $data ) != 3 )
return 'Data invalida';
return true;
}
}
?>
Já está quase tudo pronto, agora basta adicionarmos o código em nosso index.php, que fará a validação dos campos. Lembra-se daquele nosso primeiro index.php não é mesmo? Ele deve ficar assim agora:
index.php
<?php
include_once('validator.class.php');
include_once('action.class.php');
$action = new Action( );
$action->run( );
if( $action->getError( ) === true ) {
$camposInvalidos = $action->getValidacao( );
foreach( $camposInvalidos as $campo=>$e ) {
if( $e !== true )
printf('Erro: campo %s - %s <br>', $campo, $e );
}
}
?>
<form method="POST">
<input type="text" name="nome" /><br />
<input type="text" name="cpf" /><br />
<input type="text" name="data" /><br />
<!-- agora vem o botão de submit, que identificará a ação que ocorre -->
<input type="submit" name="acao" value="Insert" />
</form>
Nestes exemplos, eu levei em conta todos os arquivos estão em um só diretório, como pode ser observado pelos include_once que faço no início do script.
Esclarecendo tudo então:
- O arquivo xml é o responsável por descrever a validação
- A propriedade validation contém o nome da classe e do método, como se fossem uma chamada estática Classe::metodo
- A propriedade when define em quais acoes o campo deve ser validado, e essa ações são separadas por ‘,’
- A propriedade name define o nome do cmapo que está sendo validado
Bom, é isso!
Como de costume, os arquivos para visualização do código seguem abaixo, pois o wordpress é tosco, e zoa todo o código, para copiar e colar.
Qualquer dúvida/comentário/sugestão/elogio/doações, não deixe de contatar-me : )
[]s
Index.php
Action.class.php
Validator.class.php
Validador.xml
