Reutilização com Grails Validators

Salve Groovistas!!

É sempre bom descobrir recursos que podem tornar o nosso código mais reutilizável.
Logo, hoje focaremos nos famosos validators do grails.

Sabemos que todas as classes que implementam o @Validatable possuem uma closure estática de nome constraints que pode empacotar algumas regras comumente ligadas ao domínio em questão, facilitando muito na hora de verificar a integridade dessas informações antes de tentar persistir o mesmo.

Depois de muito tempo criando e alterando constraints, eu comecei a ficar incomodado com tanta repetição de código e decidi averiguar a possibilidade de tornar o meu código um pouco mais reutilizável. Foi ai que encontrei três maneiras de reutilizar os validadores do grails.

Podemos separar os validadores reutilizáveis em três categorias:
Empacotados
Globais
Formulário de CommandObject

1 – Empacotados:
Neste caso não é preciso muito conhecimento em grails, pois estamos apenas utilizando orientação a objetos.

Onde pegamos o que se repete e separamos em uma classe, sendo que a única novidade é a maneira que chamamos esse código.

// É sempre bom descobrir recursos que podem tornar nosso projeto mais reutilizável.
class Validators {

    static final confirmPasswordValidator = { value, command ->
        if (command.password != command.confirmPassword) {
            return 'command.confirmPassword.error.mismatch'
        }
    }

    static def requiresAtleastOne =  {val, obj->
        if(!val?.size()){
            return "default.requires.atleast.one"
        }
    }
}
class MyDomain {
        static constraints = {
              items(validator: requiresAtleastOne)
        }
}

Primeiro criamos a classe que ira empacotar as nossas validações, para logo em seguida criar as nossas validações como closures estáticas com seus parâmetros de entrada, lógica de verificação e mensagem de erro para o retorno caso seja necessário.
Para que essa classe seja utilizada como validação, precisamos apenas chama-la de dentro da constraints de nossa classe em questão seguindo a seguinte convenção <atributo_da_classe_local>(<classe_de_validacao>:<closure_de_validacao>). Simples assim.

2 – Globais:
Também podemos reaproveitar nossas validações utilizando o “Global Constraints”
Este é um recurso que precisa ser configurado de dentro do grails-app/conf/Config.groovy. Definindo validações genéricas que serão seguidas por todos os nossos domínios.

//Tambem podemos reaproveitar nossas validações com o "Global Constraints ".

//Podemos aplicar este recurso de dentro do grails-app/conf/Config.groovy
//Definindo validações para todos os domínios
grails.gorm.default.constraints = {
    '*'(nullable: true, size: 1..20)
}

// Ou até até criando diferentes validações globais
grails.gorm.default.constraints = {
    myShared(nullable: true, size: 1..20)
}

//Que pode ser chamadas da seguinte forma
class User {
    static constraints = {
        login(shared: "myShared")
    }
}

3 – Formulário de CommandObject:
Por último, temos o importForm muito utilizado em projetos que seguem o conceito de command object.

Neste caso temos duas classes de cara, o nosso domínio e o seu respectivo Command Object. Praticamente replicamos o constraints do Domain no Command Object, mas seus problemas acabaram!!!!

Com o importForm, no lugar de reescrevermos todas as validações do Domain, nós precisamos apenas escrever importForm . Mais simples impossível!

Segue um exemplo mostrando sua utilização e praticidade:

//Outro recurso que chamou bastante minha atenção foi o importForm.
//Este é um recurso muito utilizado para replicar as validações do domínio para o seu command object.

//Digamos que em nosso projeto tenhamos o seguinte domínio:
class User {
    String firstName
    String lastName
    String passwordHash
    static constraints = {
        firstName blank: false, nullable: false
        lastName blank: false, nullable: false
        passwordHash blank: false, nullable: false
    }
}

//Podemos com o importForm replicar as validações do domínio para o nosso command:
class UserCommand {
    String firstName
    String lastName
    String password
    String confirmPassword
    static constraints = {
        importFrom User

        password blank: false, nullable: false
        confirmPassword blank: false, nullable: false
    }
}

Se você conhece outra maneira de reaproveitar seus validadores não deixe de compartilhar. Comente no post.

Anúncios

2 pensamentos sobre “Reutilização com Grails Validators

  1. Alexandre disse:

    Deve funcionar também se criar uma Classe na pasta /src/groovy (ex: MediaValidator.groovy) e dentro dela jogar as closures para depois importar no Command e utilizar em vários arquivos ao mesmo tempo.

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: