Olá pessoal,

Estou passando por um problema para customizar o spring security com classes do meu sistema.

Eu já tenho uma solução, mas estou a procura de uma mais elegante. Eu não sei se a solução que estou procurando é possível de ser aplicada, apesar de, logicamente, ter sentido o que estou procurando.

Eu tenho três classes:
- Usermodule
- Profile
- Ruleprofile

As suas implementações são simples. Vide abaixo:

class Usermodule implements Serializable { 

        transient springSecurityService; 
        transient UsermoduleService; 

        String name; 

        String login; 

        String username 
        String password; 

        String email; 

        String description; 

        Boolean valid = Boolean.TRUE; 

        static hasMany = [profiles: Profile, modulos: Module] 

        public String toString() { 
                return this.name 
        } 

        static constraints = { 
                name(blank:Boolean.FALSE, nullable: Boolean.FALSE) 
                login(blank:Boolean.FALSE, nullable: Boolean.FALSE, unique: Boolean.TRUE) 
                password(blank:Boolean.FALSE, nullable: Boolean.FALSE, password: Boolean.TRUE) 
                email(blank:Boolean.FALSE, nullable: Boolean.FALSE, unique: Boolean.TRUE) 
                description(blank:Boolean.TRUE, nullable: Boolean.TRUE) 
                valid(blank:Boolean.FALSE, nullable: Boolean.FALSE) 
        } 


        static mapping = { 
                password column: '`password`' 
        } 

        def beforeInsert() { 
                encodePassword() 
        } 

        def beforeUpdate() { 
                if (isDirty('password')) { 
                        encodePassword() 
                } 
        } 

        protected void encodePassword() { 
                password = springSecurityService.encodePassword(password) 
        } 

        Set<Ruleprofile> getAuthorities() { 
                UsermoduleService.getUserProfileRules(this.id) as Set 
        } 
} 

class Ruleprofile implements Serializable { 

        String authority 

        String name 
        String description 

        static belongsTo = Profile 

        static hasMany = [profiles: Profile] 

        static constraints = { 
                name(nullable:false, blank:false, unique:true) 
                description(nullable:true, blank:true) 
                authority(nullable:false, blank:false, unique:true) 
        } 

        static mapping = { 
                cache true 
        } 

        @Override 
        public String toString() { 
                return authority; 
        } 
} 

class Profile implements Serializable{ 
        String name 
        String description 

        Module module 

        static belongsTo = [Module, Usermodule] 

        static hasMany = [rules: Ruleprofile, users: Usermodule] 

        public String toString() { 
                return this.name 
        } 

        static constraints = {	 name(blank:false, nullable:false, unique:true) 
                description(blank:true, nullable:true) 
                module(blank:true, nullable:true) 
        } 
} 

Tenho uma classe de serviço usada para resolver a lógica de busca por regras:

class UsermoduleService { 

        public def getUserProfileRules(Long id) { 
                def usermoduleInstance = Usermodule.get(id) 
                Set<Ruleprofile> rules = new HashSet<Ruleprofile>(); 

                if (usermoduleInstance) { 
                        usermoduleInstance.profiles.each{ profile-> 
                                rules.addAll(profile.rules); 
                        } 
                } 

                return rules; 
        } 
} 

Como eu mudei a forma como o comando "s2-quickstart" trabalha, eu mudei o mapeamento na classe Config.groovy para:

grails.plugins.springsecurity.userLookup.userDomainClassName = 'br.com.ntc.moduloseguranca.Usermodule' 
grails.plugins.springsecurity.authority.className = 'br.com.ntc.moduloseguranca.Ruleprofile' 

Quando eu defino uma regra:

@Secured(['ROLE_ADMIN']) 
def create() { 
  [usermoduleInstance: new Usermodule(params)] 
} 

Mesmo que um usuário tenha uma perfil com a regra definida acima, o sistema não deixa acessar o método. Nem mesmo entra no método da classe de serviço definida acima ("getUserProfileRules").

Há alguma mapeamento que esteja faltando para que o sistema entenda de onde buscar as regras?

Desde já abrigadeço.