As mentioned before, there is no pre-built way to input all of our controllers and actions into the Acl. However, we all hate doing repetitive things like typing in what could be hundreds of actions in a large application. I've whipped up an automated function to build my Aco table. This function will look at every controller in your application. It will add any non-private, non Controller methods to the Acl table, nicely nested underneath the the owning controller. You can add and run this in your AppController or any controller for that matter, just be sure to remove it before putting your application into production.

/**
 * Rebuild the Acl based on the current controllers in the application
 *
 * @return void
 */
    function buildAcl() {
        $log = array();
 
        $aco =& $this->Acl->Aco;
        $root = $aco->node('controllers');
        if (!$root) {
            $aco->create(array('parent_id' => null, 'model' => null, 'alias' => 'controllers'));
            $root = $aco->save();
            $root['Aco']['id'] = $aco->id; 
            $log[] = 'Created Aco node for controllers';
        } else {
            $root = $root[0];
        }   
 
        App::import('Core', 'File');
        $Controllers = Configure::listObjects('controller');
        $appIndex = array_search('App', $Controllers);
        if ($appIndex !== false ) {
            unset($Controllers[$appIndex]);
        }
        $baseMethods = get_class_methods('Controller');
        $baseMethods[] = 'buildAcl';
 
        // look at each controller in app/controllers
        foreach ($Controllers as $ctrlName) {
            App::import('Controller', $ctrlName);
            $ctrlclass = $ctrlName . 'Controller';
            $methods = get_class_methods($ctrlclass);
 
            // find / make controller node
            $controllerNode = $aco->node('controllers/'.$ctrlName);
            if (!$controllerNode) {
                $aco->create(array('parent_id' => $root['Aco']['id'], 'model' => null, 'alias' => $ctrlName));
                $controllerNode = $aco->save();
                $controllerNode['Aco']['id'] = $aco->id;
                $log[] = 'Created Aco node for '.$ctrlName;
            } else {
                $controllerNode = $controllerNode[0];
            }
 
            //clean the methods. to remove those in Controller and private actions.
            foreach ($methods as $k => $method) {
                if (strpos($method, '_', 0) === 0) {
                    unset($methods[$k]);
                    continue;
                }
                if (in_array($method, $baseMethods)) {
                    unset($methods[$k]);
                    continue;
                }
                $methodNode = $aco->node('controllers/'.$ctrlName.'/'.$method);
                if (!$methodNode) {
                    $aco->create(array('parent_id' => $controllerNode['Aco']['id'], 'model' => null, 'alias' => $method));
                    $methodNode = $aco->save();
                    $log[] = 'Created Aco node for '. $method;
                }
            }
        }
        debug($log);
    }

1. /**
2. * Rebuild the Acl based on the current controllers in the application
3. *
4. * @return void
5. */
6. function buildAcl() {
7. $log = array();
9. $aco =& $this->Acl->Aco;
10. $root = $aco->node('controllers');
11. if (!$root) {
12. $aco->create(array('parent_id' => null, 'model' => null, 'alias' => 'controllers'));
13. $root = $aco->save();
14. $root['Aco']['id'] = $aco->id;
15. $log[] = 'Created Aco node for controllers';
16. } else {
17. $root = $root[0];
18. }
20. App::import('Core', 'File');
21. $Controllers = Configure::listObjects('controller');
22. $appIndex = array_search('App', $Controllers);
23. if ($appIndex !== false ) {
24. unset($Controllers[$appIndex]);
25. }
26. $baseMethods = get_class_methods('Controller');
27. $baseMethods[] = 'buildAcl';
29. // look at each controller in app/controllers
30. foreach ($Controllers as $ctrlName) {
31. App::import('Controller', $ctrlName);
32. $ctrlclass = $ctrlName . 'Controller';
33. $methods = get_class_methods($ctrlclass);
35. // find / make controller node
36. $controllerNode = $aco->node('controllers/'.$ctrlName);
37. if (!$controllerNode) {
38. $aco->create(array('parent_id' => $root['Aco']['id'], 'model' => null, 'alias' => $ctrlName));
39. $controllerNode = $aco->save();
40. $controllerNode['Aco']['id'] = $aco->id;
41. $log[] = 'Created Aco node for '.$ctrlName;
42. } else {
43. $controllerNode = $controllerNode[0];
44. }
46. //clean the methods. to remove those in Controller and private actions.
47. foreach ($methods as $k => $method) {
48. if (strpos($method, '_', 0) === 0) {
49. unset($methods[$k]);
50. continue;
51. }
52. if (in_array($method, $baseMethods)) {
53. unset($methods[$k]);
54. continue;
55. }
56. $methodNode = $aco->node('controllers/'.$ctrlName.'/'.$method);
57. if (!$methodNode) {
58. $aco->create(array('parent_id' => $controllerNode['Aco']['id'], 'model' => null, 'alias' => $method));
59. $methodNode = $aco->save();
60. $log[] = 'Created Aco node for '. $method;
61. }
62. }
63. }
64. debug($log);
65. }

You might want to keep this function around as it will add new ACO's for all of the controllers & actions that are in your application any time you run it. It does not remove nodes for actions that no longer exist though. Now that all the heavy lifting is done, we need to set up some permissions, and remove the code that disabled AuthComponent earlier.

Now, once you get this working, you may notice that you have trouble accessing any plugins that you may be using. The trick to automating the controller ACOs for plugins, is that the App::import needs to follow the plugin naming convention of PluginName.PluginControllerName.

So what we need is a function that will give us a list of plugin controller names, and import them in the same way we did in the code above for the regular controllers. The function below will do just that:

    /**
     * Get the names of the plugin controllers ...
     * 
     * This function will get an array of the plugin controller names, and
     * also makes sure the controllers are available for us to get the 
     * method names by doing an App::import for each plugin controller.
     *
     * @return array of plugin names.
     *
     */
    function _get_plugin_controller_names(){
        App::import('Core', 'File', 'Folder');
        $paths = Configure::getInstance();
        $folder =& new Folder();
        // Change directory to the plugins
        $folder->cd(APP.'plugins');
        // Get a list of the files that have a file name that ends
        // with controller.php
        $files = $folder->findRecursive('.*_controller\.php');
        // Get the list of plugins
        $Plugins = Configure::listObjects('plugin');

        // Loop through the controllers we found int the plugins directory
        foreach($files as $f => $fileName)
        {
            // Get the base file name
            $file = basename($fileName);

            // Get the controller name
            $file = Inflector::camelize(substr($file, 0, strlen($file)-strlen('_controller.php')));

            // Loop through the plugins
            foreach($Plugins as $pluginName){
                if (preg_match('/^'.$pluginName.'/', $file)){
                    // First get rid of the App controller for the plugin
                    // We do this because the app controller is never called
                    // directly ...
                    if (preg_match('/^'.$pluginName.'App/', $file)){
                        unset($files[$f]);
                    } else {
                                    if (!App::import('Controller', $pluginName.'.'.$file))
                                    {
                                        debug('Error importing '.$file.' for plugin '.$pluginName);
                                    }

                        /// Now prepend the Plugin name ...
                        // This is required to allow us to fetch the method names.
                        $files[$f] = $file;
                    }
                    break;
                }
            }
        }

        return $files;
    }

1. /**
2. * Get the names of the plugin controllers ...
3. *
4. * This function will get an array of the plugin controller names, and
5. * also makes sure the controllers are available for us to get the
6. * method names by doing an App::import for each plugin controller.
7. *
8. * @return array of plugin names.
9. *
10. */
11. function _get_plugin_controller_names(){
12. App::import('Core', 'File', 'Folder');
13. $paths = Configure::getInstance();
14. $folder =& new Folder();
15. // Change directory to the plugins
16. $folder->cd(APP.'plugins');
17. // Get a list of the files that have a file name that ends
18. // with controller.php
19. $files = $folder->findRecursive('.*_controller\.php');
20. // Get the list of plugins
21. $Plugins = Configure::listObjects('plugin');
22. // Loop through the controllers we found int the plugins directory
23. foreach($files as $f => $fileName)
24. {
25. // Get the base file name
26. $file = basename($fileName);
27. // Get the controller name
28. $file = Inflector::camelize(substr($file, 0, strlen($file)-strlen('_controller.php')));
29. // Loop through the plugins
30. foreach($Plugins as $pluginName){
31. if (preg_match('/^'.$pluginName.'/', $file)){
32. // First get rid of the App controller for the plugin
33. // We do this because the app controller is never called
34. // directly ...
35. if (preg_match('/^'.$pluginName.'App/', $file)){
36. unset($files[$f]);
37. } else {
38. if (!App::import('Controller', $pluginName.'.'.$file))
39. {
40. debug('Error importing '.$file.' for plugin '.$pluginName);
41. }
42. /// Now prepend the Plugin name ...
43. // This is required to allow us to fetch the method names.
44. $files[$f] = $file;
45. }
46. break;
47. }
48. }
49. }
50. return $files;
51. }

You can then either modify the original code to include the plugin controllers by merging them with the list you got (place this before the foreach loop):

        $Plugins = $this->_get_plugin_controller_names();

        $Controllers = array_merge($Controllers, $Plugins);

1. $Plugins = $this->_get_plugin_controller_names();
2. $Controllers = array_merge($Controllers, $Plugins);