def enforcerService
enforcerService.enforce({ hasDomainRole('owner', sprocket, testUser) })

def enforcerService
enforcerService.enforce({ hasRole('ROLE_USER', testUser) })

@Enforce({hasRole('ROLE_USER', testUser)  && hasDomainRole('owner', sprocket, testUser)})
def someMethod(){
    //some logic
}

@Reinforce({hasRole('ROLE_USER', testUser)  && hasDomainRole('owner', sprocket, testUser)})
def someMethod(){
    //some logic
}

@ReinforceFilter({ Object o -> (o as List).findResults { it % 2 == 0 ? it : null } })
    List<Integer> reinforceFilter() {
        [1, 2, 3, 4, 5, 6, 7, 8, 9]
    }

class DomainRole {
    String role        //The role to apply to the object
    Long   domainId    //The id of the object
    String domainName  //The domain name of the object
    User   user        //The user associated with the permission
    Date   dateCreated
    Date   lastUpdated

    /**
     *  This method will check if a user(defaulting to the currently logged in user),
     *  has a DomainRole on an object.
     *
     *  @param  role the role to check to see if the user has on the domainObject
     *  @param domainObject the instance of the domain object to check if the user
     *  has a DomainRole on
     *  @param user the user to check if  it has the role on the domain object,
     *  defaults to null which is swapped for springSecurityService.currentUser
     *  @return true if the user has the DomainRole or the DomainRole fall in to
     *  the following hierarchy and false other wise:
     *  Map roleHierarchy = [
     *            owner : ['owner', 'editor', 'viewer'],
     *            editor: ['editor', 'viewer'],
     *            viewer: ['viewer']
     *  ]
     */
    boolean hasDomainRole(String role, domainObject, User user = null)

    /**
     * This method checks the domain object to see if it has a reference to a
     * user(passed in or defaulted to springSecurityService.currentUser)
     * This makes it so that the original creator of an object can add permissions
     * to that object.
     *
     * @param domainObject The domain object to check for a user reference
     * domainObject.creator
     * @param user  the user(defaulted to springSecurityService.currentUser) to
     * compare to domainObject.creator
     * @return true if the user is the same as the creator user reference, false
     * otherwise
     */
    Boolean isCreator(domainObject, user = null)

    /**
     * This method changes the DomainRole of a domainObject for a user, and
     * creates one if one doesn't exist.
     *
     * @param role the role to set for the domainObject
     * @param domainObject the domain object to set a role for
     * @param user the user to set the DomainRole for defaulting to
     * springSecurityService.currentUser
     */
    void changeDomainRole(String role, domainObject, User user = null)

    /**
     * This method removes a DomainRole from an  domainObject
     *
     * @param domainObject the domainObject to remove the role from
     * @param user the use for which the role is being removed.
     */
    void removeDomainRole(domainObject, User user = null)

@EnforceTS({ isCreator(sprocket) })
Sprocket updateSprocketCompileStatic(Sprocket sprocket) {
    sprocket.material = 'plastic'
    (Sprocket)sprocket.save()
}

 com.security.enforcer.EnforcerService enforcerService

@com.virtualdogbert.ast.EnforceTS(value = {
    this.isCreator(sprocket)
}, extensions = ['org.grails.compiler.ValidateableTypeCheckingExtension', 'org.grails.compiler.NamedQueryTypeCheckingExtension', 'org.grails.compiler.HttpServletRequestTypeCheckingExtension', 'org.grails.compiler.WhereQueryTypeCheckingExtension', 'org.grails.compiler.DynamicFinderTypeCheckingExtension', 'org.grails.compiler.DomainMappingTypeCheckingExtension', 'org.grails.compiler.RelationshipManagementMethodTypeCheckingExtension'])
public com.security.Sprocket updateSprocketCompileStatic(com.security.Sprocket sprocket) {
    return ((this.$Enforcer_wrapped_method_updateSprocketCompileStatic(sprocket)) as com.security.Sprocket)
}

@grails.gorm.transactions.Transactional
@groovy.transform.CompileStatic
protected com.security.Sprocket $Enforcer_wrapped_method_updateSprocketCompileStatic(com.security.Sprocket sprocket) {
    org.grails.datastore.mapping.transactions.CustomizableRollbackTransactionAttribute $transactionAttribute = new org.grails.datastore.mapping.transactions.CustomizableRollbackTransactionAttribute()
    grails.gorm.transactions.GrailsTransactionTemplate $transactionTemplate = new grails.gorm.transactions.GrailsTransactionTemplate( this .transactionManager, $transactionAttribute)
    return (($transactionTemplate.execute({ org.springframework.transaction.TransactionStatus transactionStatus ->
        this.$tt__$Enforcer_wrapped_method_updateSprocketCompileStatic(sprocket, transactionStatus)})) as com.security.Sprocket)
}

protected com.security.Sprocket $tt__$Enforcer_wrapped_method_updateSprocketCompileStatic(com.security.Sprocket sprocket, org.springframework.transaction.TransactionStatus transactionStatus) {
    enforcerService.enforce({
        this.isCreator(sprocket)
    })
    sprocket .material = 'plastic'
    ((sprocket.save()) as com.security.Sprocket)
}