Como utilizar ?

Como fazer utilizar a API Imaginary.Validator.Vamos inicialmente ver os conceitos ( arquitetura ) da api para entender o seu funcionamento, depois como utilizar e alterar as mensagens de dados invalidos.

Conceitos : Validadores , Regras e mensagens

Vamos definir um exemplo para a validação de dados, um formulário medico  para os funcionários de uma empresa solicitar exame medico de rotina.

nome
do medico		 Tamanho minimo:3
Tamanho maximo:80
Requerido		 exemplo:
Mario Ananias
e-mail
do medico		 e-mail valido mario@med.net
CRM Requerido exemplo:
Mario Ananias
Seu peso
atual		 maior que 0
Sua
altura		 maior que 0
Sua
idade		 maior que 0
Requerido
Valor
Consulta		 maior que 0
Requerido
Data
Consulta		 maior que 0
Requerido
  • Exemplo como uma validação normalmente e feita: 
      
                String nomeMedico = "Jose Mane Ortis"; 
                String emailMedico="mane@mail.net";
                Double pesoPaciente=82.34;
                
                
                //nomeMedico ->Tamanho minimo:3 | Tamanho maximo:80 | Requerido
                if(nomeMedico==null)
                {
                        throw new IllegalArgumentException("Nome do medico deve ser preenchido");
                        
                }else if (nomeMedico.length() < 3  ||  nomeMedico.length() > 80)
                {
                        throw new 
                       IllegalArgumentException(
                             "Nome do medico dever ter um tamanho minimo de 3 e máximo de 256 Caracteres");
                }
                
                //emailMedico -> e-mail valido | não e requerido (não obrigatório)
                String patternEmail =
                        "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[_A-Za-z0-9-]+)";
                
                if ((emailMedico!=null || !emailMedico.isEmpty() ) && !emailMedico.matches(patternEmail))
                {
                        throw new IllegalArgumentException("e-mail do medico invalido.");
                }
                
                //Seu peso  atual -> maior que 0 | Requerido 
                if(pesoPaciente==null )
                {
                        throw new IllegalArgumentException("Peso deve ser preenchido.");
                        
                }else if ( pesoPaciente <=  0 )
                {
                        throw new IllegalArgumentException("Peso deve ser maior que 0.");
                }

    Podemos observar que no trecho de codigo estamos validando o nome do medico, e obrigatorio o preenchimento e deve possuir mais que 3 caracteres e menos que 256 caracteres.

    A validação e denominado na api de Validator , o validator agrega um conjunto de verificações(regras) para validação.Cada regra para verificação e denomidado de ValidatorRule , cada if no codigo acima pode ser definindo como uma regra para verificação.As mensagens são colocadas em um arquivo de propriedades, chave da regra que e violada, e mensagem para ser exibida para o usuario.

Utilizando

Utilizando a API Imaginary.Validator, o codigo fica mais simples e padronizado, e as mensagens podem ser facilmentes alteradas no arquivo de mensagens invalidas sem ter que sair verficando em todo o codigo, onde esta o erro de portugues da mensagem, ou alterar a mensagen que e exibida.Veja o codigo de validação que foi exibido acima com a API Imaginary.Validator.

                String nomeMedico = "Mane"; 
                String emailMedico="mane@mail.net";
                Double pesoPaciente=82.34;
                
                //Lista para adicionar as validações
                List<Validator<? extends Object>> validaList = new ArrayList<Validator<? extends Object>>();
                
                //nomeMedico ->Tamanho minimo:3 | Tamanho maximo:80 | Requerido         
                // <- Criação de uma Validator do tipo String , o construtor deve possuir um nome para obter 
                //as mensagens de dados invalidos, caso os dados não estiverem ok. 
                Validator<String> validarNomeMedico = new Validator<String>("nomeMedico", nomeMedico ); 
                
                //Regras- substituição dos ifs          
                  //Regra - Requerido
                  ValidatorRule  requerido = new RequiredRule();
                   //adicionar a regra ao validador do nome do medico.
                  validarNomeMedico.addRule(requerido);
                  
                  //Regra -Tamanho minimo:3 | Tamanho maximo:80
                  ValidatorRule<String> regraTamMinMax = new StrMinMaxSizeRule();
                  //Parametro para a regra StrMinMaxSizeRule
                  regraTamMinMax.addParameter(StrMinMaxSizeRule.PARAM_MIN_SIZE, 3);
                  regraTamMinMax.addParameter(StrMinMaxSizeRule.PARAM_MAX_SIZE, 80);
                  //adicionar a regra ao validador
                  validarNomeMedico.addRule(regraTamMinMax);
                  
                  //adicionar o validador para ser executado depois. 
                  validaList.add(validarNomeMedico);
              
                  //e-mail não e requerido por isto tem que ser verificado antes para validar 
                  if (!ValidatorUtil.isEmpty(emailMedico))
                  {
                          Validator<String> validatorEmail = new Validator<String>("emailMedico", emailMedico); 
                          ValidatorRule<String> emailRule = new MailRule();
                          validatorEmail.addRule(emailRule);
                          validaList.add(validatorEmail);                 
                  }
                
                  //Seu peso  atual -> maior que 0 , requerido 
                  Validator<Number> validaPesoPaciente = new Validator<Number>("validaPesoPaciente", pesoPaciente);
                  
                  ValidatorRule requeridoPesoPaciente = new RequiredRule();
                  //adiciona a regra requerido 
                  validaPesoPaciente.addRule(requeridoPesoPaciente);
                  //Regra para verificar o minimo
                  ValidatorRule<Number>  minPeso = new NumberMinRule();
                  minPeso.addParameter(NumberMinRule.PARAM_MIN, 0);
                  
                  validaPesoPaciente.addRule(minPeso);
                                  
                  validaList.add(validaPesoPaciente);
                
                   //Cada metodo Validator tem um metodo validate que retorna um Map<>
                   //Na api tem um metodo utilitario para executar um conjunto de validadores.
                  
                  //Map com as mensagens de dados invalidos, so vai existir mensagens de dados invalidos, caso 
                  // os dados não estiver de acordo com as regras de validação.
 
                  Map<String,Map<String, Map<String,String>>> erros = ValidatorManager.validate(validaList);

                      // <-Chave com os nomes do validador, exemplo: "emailMedico"
                             //<-Map com as regras  invalidas 
                                //<-Chave com o nome da chave da regra.Exemplo "required"
                                         //<- Map com as mensagens da regra que seja invalida.
                                             //<-Chave com o nome da regra que da regra que 
                                             //                              foi violada.Exemplo:"STR_EMAIL_INVALID"
                                                    //<- Mensagem do dado invalido.Exemplo:Email mane.mail.net invalido.

Customizando o arquivo de mensagens, para os dados invalidos

rererwerwererwererwerwerrrwe.
erewrwerwerwerewrewrewrwerwerwe.
erewrerwererwerwerewrewrwererer.