sampleEnforcer_tranformed.groovy

package com.security.enforcer

import grails.plugin.springsecurity.SpringSecurityService as SpringSecurityService
import org.springframework.beans.factory.annotation.Autowired as Autowired
import com.security.Sprocket as Sprocket
import grails.gorm.transactions.Transactional as Transactional
import com.virtualdogbert.ast.*

@com.virtualdogbert.ast.EnforcerTransactional
public class com.security.enforcer.EnforcerTestTService extends java.lang.Object { 

    private grails.plugin.springsecurity.SpringSecurityService springSecurityService 
    com.security.enforcer.EnforcerService enforcerService 
    protected org.springframework.transaction.PlatformTransactionManager $transactionManager 
    protected org.grails.datastore.mapping.core.Datastore $targetDatastore 

    @grails.gorm.transactions.Transactional
    @groovy.transform.CompileStatic
    public com.security.Sprocket createSprocket() {
        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__createSprocket(transactionStatus)})) as com.security.Sprocket)
    }

    @com.virtualdogbert.ast.EnforceT(value = { 
        this.isCreator(sprocket)
    })
    public com.security.Sprocket updateSprocket(com.security.Sprocket sprocket) {
        return ((this.$Enforcer_wrapped_method_updateSprocket(sprocket)) as com.security.Sprocket)
    }

    @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)
    }

    @com.virtualdogbert.ast.Enforce(value = { 
        this.isCreator(sprocket)
    })
    public com.security.Sprocket getSprocket(com.security.Sprocket sprocket) {
        return ((this.$Enforcer_wrapped_method_getSprocket(sprocket)) as com.security.Sprocket)
    }

    @grails.gorm.transactions.Transactional
    @groovy.transform.CompileStatic
    protected com.security.Sprocket $Enforcer_wrapped_method_updateSprocket(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_updateSprocket(sprocket, transactionStatus)})) as com.security.Sprocket)
    }

    public org.springframework.transaction.PlatformTransactionManager getTransactionManager() {
        if ( $transactionManager != null) {
            return $transactionManager 
        } else {
            return org.grails.datastore.gorm.GormEnhancer.findSingleTransactionManager()
        }
    }

    public void setTransactionManager(org.springframework.transaction.PlatformTransactionManager transactionManager) {
        $transactionManager = transactionManager 
    }

    @org.springframework.beans.factory.annotation.Autowired(required = false)
    @groovy.transform.CompileStatic
    public void setTargetDatastore(org.grails.datastore.mapping.core.Datastore[] datastores) {
        $targetDatastore = org.grails.datastore.gorm.internal.RuntimeSupport.findDefaultDatastore( datastores )
        if (org.grails.datastore.gorm.internal.RuntimeSupport.findDefaultDatastore( datastores ) != null) {
            $transactionManager = ((org.grails.datastore.gorm.internal.RuntimeSupport.findDefaultDatastore( datastores )) as org.grails.datastore.mapping.transactions.TransactionCapableDatastore).getTransactionManager()
        }
    }

    @groovy.transform.CompileStatic
    protected org.grails.datastore.mapping.core.Datastore getTargetDatastore(java.lang.String connectionName) {
        if ( $targetDatastore != null) {
            return $targetDatastore.getDatastoreForConnection( connectionName )
        } else {
            return org.grails.datastore.gorm.GormEnhancer.findSingleDatastore().getDatastoreForConnection( connectionName )
        }
    }

    @groovy.transform.CompileStatic
    protected org.grails.datastore.mapping.core.Datastore getTargetDatastore() {
        if ( $targetDatastore != null) {
            return $targetDatastore 
        } else {
            return org.grails.datastore.gorm.GormEnhancer.findSingleDatastore()
        }
    }

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

    @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)
    }

    protected com.security.Sprocket $Enforcer_wrapped_method_getSprocket(com.security.Sprocket sprocket) {
        enforcerService.enforce({ 
            this.isCreator(sprocket)
        })
        return sprocket 
    }

    protected com.security.Sprocket $tt__createSprocket(org.springframework.transaction.TransactionStatus transactionStatus) {
        springSecurityService .currentUser
        com.security.Sprocket sprocket = new com.security.Sprocket(['material': 'metal', 'creator': springSecurityService .currentUser])
        sprocket.save()
    }

}