Reading out all actions in a Grails-Controller

Question

I need to read out all available actions from any controller in my web-app. The reason for this is an authorization system where I need to give users a list of allowed actions.

E.g.: User xyz has the authorization for executing the actions show, list, search. User admin has the authorization for executing the actions edit, delete etc.

I need to read out all actions from a controller. Does anyone has an idea?

score 9 · Answer 1 · answered Jun 02 '10 at 15:17

This will create a List of Maps (the 'data' variable) with controller information. Each element in the List is a Map with keys 'controller', corresponding to the URL name of the controller (e.g. BookController -> 'book'), controllerName corresponding to the class name ('BookController'), and 'actions' corresponding to a List of action names for that controller:

import org.springframework.beans.BeanWrapper
import org.springframework.beans.PropertyAccessorFactory

def data = []
for (controller in grailsApplication.controllerClasses) {
    def controllerInfo = [:]
    controllerInfo.controller = controller.logicalPropertyName
    controllerInfo.controllerName = controller.fullName
    List actions = []
    BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(controller.newInstance())
    for (pd in beanWrapper.propertyDescriptors) {
        String closureClassName = controller.getPropertyOrStaticPropertyOrFieldValue(pd.name, Closure)?.class?.name
        if (closureClassName) actions << pd.name
    }
    controllerInfo.actions = actions.sort()
    data << controllerInfo
}

Does this code still work with Grails 2? I mean, in Grails2, controllers are not closures anymore — fabien7474, Nov 10 '12 at 14:32
Closures are still supported, but methods are preferred. I 2.0 you can search for methods with the @grails.web.Action annotation — Burt Beckwith, Nov 10 '12 at 18:23
@BurtBeckwith Can we get beforeInterceptor from using controllerClasses? — user1791574, Jul 09 '15 at 08:13

Dónal · Answer 2 · 2013-06-05T10:04:25.597

Here's an example that works with Grails 2, i.e it will capture actions defined as either methods or closures

import org.codehaus.groovy.grails.commons.DefaultGrailsControllerClass
import java.lang.reflect.Method
import grails.web.Action

// keys are logical controller names, values are list of action names  
// that belong to that controller
def controllerActionNames = [:]

grailsApplication.controllerClasses.each { DefaultGrailsControllerClass controller ->

    Class controllerClass = controller.clazz

    // skip controllers in plugins
    if (controllerClass.name.startsWith('com.mycompany')) {
        String logicalControllerName = controller.logicalPropertyName

        // get the actions defined as methods (Grails 2)
        controllerClass.methods.each { Method method ->

            if (method.getAnnotation(Action)) {
                def actions = controllerActionNames[logicalControllerName] ?: []
                actions << method.name

                controllerActionNames[logicalControllerName] = actions
            }
        }
    }
}

score 4 · Answer 3 · answered May 22 '12 at 16:33

Grails does not support a straightforward way to do this. However, I was able to put together a puzzle from available grails methods and have come to this solution:

def actions = new HashSet<String>()
def controllerClass = grailsApplication.getArtefactInfo(ControllerArtefactHandler.TYPE)
                         .getGrailsClassByLogicalPropertyName(controllerName)
for (String uri : controllerClass.uris ) {
    actions.add(controllerClass.getMethodActionName(uri) )
}

Variables grailsApplication and controllerName are injected by grails. As controller itself does not have necessary methods, this code retrieves its controllerClass (see GrailsControllerClass), which has what we need: property uris and method getMethodActionName

score 4 · Answer 4 · answered Oct 17 '13 at 23:53

To print out a list of all the methods with action names:

   grailsApplication.controllerClasses.each {
               it.getURIs().each {uri ->
                 println  "${it.logicalPropertyName}.${it.getMethodActionName(uri)}"
               }
   }

score 0 · Answer 5 · answered Apr 15 '19 at 10:30

I had to pull a list of all controllers and their respective URI. This is what I did on a grails 3.1.6 application.

grailsApplication.controllerClasses.each { controllerArtefact ->
            def controllerClass = controllerArtefact.getClazz()
            def actions = controllerArtefact.getActions()
            actions?.each{action->
                def controllerArtefactString = controllerArtefact.toString()
                def controllerOnly = controllerArtefactString.split('Artefact > ')[1]
                println "$controllerOnly >>>> $controllerOnly/${action.toString()}"
            }
        }

Reading out all actions in a Grails-Controller

5 Answers5

Linked