Validações customizadas no Asp.Net MVC | Alura Cursos Online
Validações customizadas no Asp.Net MVC
7 min7 minutos de leitura
7 min7 minutos de leitura
Uma das formas de fazer validação em uma aplicação Asp.Net MVC é utilizar as anotações (Attributes) definidos no namespace System.ComponentModel.DataAnnotations. Se quisermos, por exemplo, que o campo nome de um modelo de usuário seja obrigatório utilizamos o RequiredAttribute:
Autor(a)
victor.harada
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
publicclassUsuario { ```Required
public String Nome { get; set; }
public String Password { get; set; } }
E dentro do controller da aplicação, podemos verificar se as informações enviadas pelo usuário são válidas utilizando o ModelState:
publicclassUsuarioController : Controller { public ActionResult Cadastra(Usuario usuario) { if(ModelState.IsValid) { // Modelo é válido } else { // Modelo é inválido } } }
Mas e se quiséssemos validar que o usuário preencheu um password forte (contém números, letras maiúsculas e minúsculas). Nesse caso, poderíamos colocar a regra de validação diretamente dentro do controller da aplicação:
publicclassUsuarioController : Controller { public ActionResult Cadastra(Usuario usuario) { Regexregex=newRegex(@"((?=.\*\\d)(?=.\*```a-z
)(?=.\*```A-Z
).{4,100})"); if(regex.IsMatch(usuario.Password)) { ModelState.AddModelError("password.Fraco", "Password muito fraco") } if(ModelState.IsValid) { // Modelo é válido } else { // Modelo é inválido } } }
Mas e se essa validação for utilizada em outros pontos da aplicação? Nesse caso, seria mais interessante se pudéssemos isolar o código da validação dentro de uma nova anotação.
Nova anotação de validação
Vamos então criar uma nova anotação de validação chamada PasswordForteAttribute. Para que possamos utilizar essa classe como uma validação no Asp.Net MVC, ela precisa herdar de ValidationAttribute:
Quando o campo não obedecer a regra de validação, precisamos informar qual é a mensagem de validação que deve ser exibida para o usuário. Para isso, precisamos passar a mensagem como argumento do construtor da classe ValidationAttribute:
publicclassPasswordForteAttribute : ValidationAttribute { publicPasswordForteAttribute() : base("Senha muito fraca") { }
// implementação da validação }
Agora precisamos simplesmente anotar o modelo com essa nova anotação e depois remover a lógica da validação customizada da action do controller, lembrando que como a classe será utilizada como anotação, não precisamos do sufixo Attribute:
publicclassUsuario { ```Required
public String Nome { get; set; }
```PasswordForte
public String Password { get; set; } }
publicclassUsuarioController : Controller { public ActionResult Cadastra(Usuario usuario) { if(ModelState.IsValid) { // Modelo é válido } else { // Modelo é inválido } } }
Agora temos um código de validação isolado e reutilizável.
Validação no navegador
Essa validação que criamos será executada quando alguma action de um controller receber um objeto do tipo usuário, ou seja, para executarmos a validação precisamos de uma requisição web! Mas quando utilizamos as anotações do namespace System.ComponentModel.DataAnnotations, a maioria delas define validações que são executadas no navegador do usuário da aplicação, tudo o que precisamos fazer para utilizar essa validação no cliente é utilizar o HtmlHelper para gerar o formulário dentro de uma view fortemente tipada, como fazemos no curso de razor do Alura:
Queremos que a nossa validação de password forte também seja executada no navegador do usuário, para isso, precisamos fazer com que a classe PasswordForteAttribute implemente a interface IClientValidatable:
Todas as classes que implementam IClientValidatable precisam informar ao Asp.Net MVC qual é o código javascript que será executado no navegador do cliente. Isso é feito através do método GetValidationRules:
O IEnumerable é o objeto que configura qual é o código javascript que será executado para fazer a validação. Dentro dele precisamos informar qual é a mensagem de validação que deve ser exibida para o usuário, o nome da regra de validação (que será utilizado para identificar qual é a função javascript que será executada) e também os parâmetros que devem ser passadas para a função de validação.
A implementação das regras de validação no navegador, no Asp.Net MVC, é feita utilizando-se uma biblioteca chamada jquery.validation.unobtrusive, então vamos incluí-la na view do formulário:
@\* código do formulário \*@
@\* Assumindo que a versão do jquery é a 1.10.2 e está na pasta Scripts do projeto \*@ <scriptsrc="~/Scripts/jquery-1.10.2.js"></script><scriptsrc="~/Scripts/jquery.validate.js"></script><scriptsrc="~/Scripts/jquery.validate.unobtrusive.js"></script>
E agora precisamos configurar o jquery validate para que ele reconheça a nova regra de validação. Para isso precisamos registrar o nome dessa nova regra de validação e os parâmetros que ela precisa (no caso, o parâmetro é a expressão regular para o password):
@\* Importa os scripts do jquery \*@ <script>// o primeiro argumento é o nome da validação // e o segundo é o nome do argumento da validação $.validator.unobtrusive.adapters.addSingleVal("passwordforte", "regex"); </script>
Para finalizar precisamos informar qual é a função de validação que será executada:
<script> $.validator.unobtrusive.adapters.addSingleVal("passwordforte", "regex");
// Aqui precisamos falar qual é o nome da regra de validação: passwordforte // e a função de validação $.validator.addMethod("passwordforte", function (value, element, regex) { // implementação da validação }); </script>
Na função de validação, recebemos 3 argumentos, o valor que está sendo validado (no caso o campo de texto para o password), o elemento html e, por fim, os parâmetros que foram passados no ValidationParameters do ModelClientValidationRule. Na implementação do método, precisamos devolver algo que avalie para true caso o value seja válido e para false, caso contrário.
<script> $.validator.unobtrusive.adapters.addSingleVal("passwordforte", "regex"); $.validator.addMethod("passwordforte", function (value, element, regex) { var passwordRegex = newRegExp(regex); return value.match(passwordRegex); }); </script>
Isso é tudo que precisamos fazer para criar uma nova validação que será executada no navegador do cliente! Podemos ainda melhorar esse código isolando os códigos de validação dentro de um arquivo javascript e importar esse arquivo dentro do layout da aplicação para que o código não fique repetido em todos os formulários.
Simplificando a validação
A validação da senha é parecida com uma outra validação que já existe no Asp.Net MVC, a RegularExpressionAttribute, e por isso podemos reutilizar uma parte do código que já está pronta no .Net para implementar a validação na view. Ao invés de utilizarmos diretamente o ModelClientValidationRule, podemos utilizar uma de suas classes filhas para utilizarmos a validação na view implementada pelo Asp.Net MVC. Para a validação com expressões regulares, utilizamos a ModelClientValidationRegexRule:
public IEnumerable GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { varrule=newModelClientValidationRegexRule("Password muito fraco", PasswordPattern); returnnewList() { rule }; }
Utilizando essa implementação para o GetClientValidationRule, só precisamos importar os códigos javascript para o jquery.validate.unobtrusive, sem implementarmos nossa própria função de validação. A implementação dessa validação pode ser encontrada nesse gist.
Para mais informações sobre a criação de validações customizadas, você pode ler o post do Brad Wilson sobre o tema e para mais um exemplo prático, temos esse artigo do code project.
