Errores debidos a controladores o acciones faltantes

Errores que ocurren dentro de controladores de acción

Establecer el parámetro useDefaultControllerAlways.

En su front controller, o en su despachador, agregue la siguiente directiva:

$front->setParam('useDefaultControllerAlways', true);

// or

$dispatcher->setParam('useDefaultControllerAlways', true);

Cuando se establece este indicador, el despachador usará el controlador y la acción por defecto en lugar de lanzar una excepción. La desventaja de este método es que cualquier error tipográfico que un usuario cometa al acceder a su sitio aún se resolverá y mostrará su página de inicio, lo que puede causar estragos con la optimización para motores de búsqueda.

La excepción lanzada por dispatch() es una Zend_Controller_Dispatcher_Exception que contiene el texto 'Invalid controller specified'. Use uno de los métodos descritos en la sección anterior para capturar la excepción, y luego redirigir a una página de error genérica o a la página de inicio.

Crear una subclase de Zend_Controller_Action y sobrescribir el método __call(). Como ejemplo:

class My_Controller_Action extends Zend_Controller_Action
{
    public function __call($method, $args)
    {
        if ('Action' == substr($method, -6)) {
            $controller = $this->getRequest()->getControllerName();
            $url = '/' . $controller . '/index';
            return $this->_redirect($url);
        }

        throw new Exception('Invalid method');
    }
}

El ejemplo anterior intercepta cualquier método de acción indefinido que se llame y lo redirige a la acción por defecto en el controlador.

Crear una subclase de Zend_Controller_Dispatcher y sobrescribir el método getAction() para verificar que la acción existe. Como ejemplo:

class My_Controller_Dispatcher extends Zend_Controller_Dispatcher
{
    public function getAction($request)
    {
        $action = $request->getActionName();
        if (empty($action)) {
            $action = $this->getDefaultAction();
            $request->setActionName($action);
            $action = $this->formatActionName($action);
        } else {
            $controller = $this->getController();
            $action     = $this->formatActionName($action);
            if (!method_exists($controller, $action)) {
                $action = $this->getDefaultAction();
                $request->setActionName($action);
                $action = $this->formatActionName($action);
            }
        }

        return $action;
    }
}

El código anterior comprueba que la acción solicitada exista en la clase controladora; si no, se restablece la acción a la acción por defecto.

Este método es conveniente porque puede alterar de forma transparente la acción antes del despacho final. Sin embargo, también significa que los errores tipográficos en la URL aún pueden despacharse correctamente, lo cual no es ideal para la optimización en motores de búsqueda.

Use Zend_Controller_Action::preDispatch() o Zend_Controller_Plugin_Abstract::preDispatch() para identificar acciones inválidas.

Al crear una subclase de Zend_Controller_Action y modificar preDispatch(), puede modificar todos sus controladores para reenviar a otra acción o redirigir antes de realmente despachar la acción. El código para esto será similar al código para sobrescribir __call(), arriba.

Alternativamente, puede comprobar esta información en un plugin global. Esto tiene la ventaja de ser independiente del controlador de acción; si su aplicación consiste en una variedad de controladores de acción, y no todos heredan de la misma clase, este método puede añadir consistencia en el manejo de sus diversas clases.

Como ejemplo:

class My_Controller_PreDispatchPlugin extends Zend_Controller_Plugin_Abstract
{
    public function preDispatch(Zend_Controller_Request_Abstract $request)
    {
        $front      = Zend_Controller_Front::getInstance();
        $dispatcher = $front->getDispatcher();
        $class      = $dispatcher->getControllerClass($request);
        if (!$class) {
            $class = $dispatcher->getDefaultControllerClass($request);
        }

        $r      = new ReflectionClass($class);
        $action = $dispatcher->getActionMethod($request);

        if (!$r->hasMethod($action)) {
            $defaultAction  = $dispatcher->getDefaultAction();
            $controllerName = $request->getControllerName();
            $response       = $front->getResponse();
            $response->setRedirect('/' . $controllerName
                                  . '/' . $defaultAction);
            $response->sendHeaders();
            exit;
        }
    }
}

En este ejemplo, comprobamos si la acción solicitada está disponible en el controlador. Si no, redirigimos a la acción por defecto en el controlador, y salimos de la ejecución del script inmediatamente.