repo_zf1/documentation/manual/es/module_specs/Zend_Controller-QuickStart.xml

<sect1 id="zend.controller.quickstart">
    <title>Zend_Controller Quick Start</title>

    <sect2 id="zend.controller.quickstart.introduction">
        <title>Introducción</title>
        <para>
            <code>Zend_Controller</code>
            es el corazón del sistema de MVC de Zend Framework MVC. MVC
            son las siglas de
            <ulink url="http://en.wikipedia.org/wiki/Model-view-controller">
                Modelo-Vista-Controlador
            </ulink>
            y es un patrón de diseño con el objetivo de separar la
            lógica de la aplicación de la lógica de visualización.
            <code>Zend_Controller_Front</code>
            implementa el patrón
            <ulink url="http://www.martinfowler.com/eaaCatalog/frontController.html">
                Front Controller (Controlador Frontal)
            </ulink>
            en el cual todas las transacciones HTTP (requests) son
            interceptadas por el controlador frontal y despachado a una
            Acción particular de un Controlador según la URL pedida.


        </para>
        <para>
            El sistema
            <code>Zend_Controller</code>
            fue construido con la extensibilidad en mente, ya sea
            heredando las clases existentes, escribiendo nuevas clases
            que implementan varias interfaces o clases abstractas que
            forman la base de la familia de clases del controlador, o
            escribiendo plugins o helpers de las acciones para aumentar
            o manipular la funcionalidad del sistema.
        </para>
    </sect2>

    <sect2 id="zend.controller.quickstart.go">
        <title>Quick Start</title>

        <para>
            Si necesita información más detallada, mire las secciones
            siguientes. Si solamente quiere inicializar y ejecutar una
            aplicación rápidamente, siga leyendo.
        </para>

        <sect3 id="zend.controller.quickstart.go.directory">
            <title>Cree su estructura de archivos</title>

            <para>
                El primer paso es crear su estructura de archivos. La
                estructura típica es la siguiente:
            </para>

            <programlisting role="php"><![CDATA[
application/
    controllers/
        IndexController.php
    models/
    views/
        scripts/
            index/
                index.phtml
        helpers/
        filters/
html/
    .htaccess
    index.php
]]></programlisting>

        </sect3>

        <sect3 id="zend.controller.quickstart.go.docroot">
            <title>Establezca su document root</title>

            <para>
                Apunte su document root en su servidor web hacia el
                directorio
                <code>html</code>
                de la estrctura de archivos de arriba.
            </para>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.rewrite">
            <title>Cree sus reglas de reescritura</title>

            <para>
                Edite el archivo
                <code>html/.htaccess</code>
                que aparece arriba de la siguiente forma:
            </para>

            <programlisting role="php"><![CDATA[
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ index.php [NC,L]
]]></programlisting>

            <para>
                La regla de arriba redigirá las peticiones a recuros existentes
                (enlaces simbólicos existentes, archivos no vacíos, o directorios no vacíos)
        en consecuencia, y todas las otras peticiones al front controller.
            </para>

            <note>
                <para>
                    Las reglas de arriba pertenecen a Apache. Para ejemplos de reglas
                    de rewrite para otros servidores web, mire la
                    <link linkend="zend.controller.router.introduction">
                        documentación de router
                    </link>
                    .
                </para>
            </note>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.bootstrap">
            <title>Cree su archivo bootstrap</title>

            <para>
                El archivo bootstrap es la página a la que todas las peticiones
                son redirigidas a través de --
                <code>html/index.php</code>
                en este caso. Abra el archivo
                <code>html/index.php</code>
                en el editor de su elección y añada lo siguiente:
            </para>

            <programlisting role="php"><![CDATA[
Zend_Controller_Front::run('/path/to/app/controllers');
]]></programlisting>

            <para>
                Esto instanciará y hará un dispatch del front controller, que
                redigirá las peticiones a los action controllers.
            </para>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.controller">
            <title>Cree su action controller por defecto</title>

            <para>
                Antes de tratar los action controllers, debe primero
                entender cómo las peticiones son redirigidas en Zend Framework.
                Por defecto, el primero segmento de una ruta URL apunta
                a un controlador, y el segundo a una acción. Por ejemplo,
                dada la URL
                <code>
                    http://framework.zend.com/roadmap/components
                </code>
                , la ruta es
                <code>/roadmap/components</code>
                , que apuntará al controlador
                <code>roadmap</code>
                y la acción
                <code>components</code>
                . Si no se suministra una acción, se asume la acción
                <code>index</code>
                , y si no se suministra un controlador, se asume el controlador
                <code>index</code>
                (siguiendo la convención de Apache de apuntar a
                <code>DirectoryIndex</code>
                automáticamente).
            </para>

            <para>
                El dispatcher de <code>Zend_Controller</code>
                toma entonces el valor del controlador y lo apunta
                a una clase. Por defecto, pone en mayúsculas la primera letra
                del nombre de controlador y agrega la palabra
                <code>Controller</code>
                . De esta forma, en nuestro ejemplo de arriba, el controlador
                <code>roadmap</code>
                es dirigido a la clase
                <code>RoadmapController</code>
                .
            </para>

            <para>
                De la misma forma, el valor de action es dirigido
                a un método de la clase controladora. Por defecto, el valor se
                pasa a minúsculas, y la palabra
                <code>Action</code>
                es añadida. De esta forma, en nuestro ejemplo de arriba, la acción
                <code>components</code>
                se convierte en
                <code>componentsAction</code>
                , y el método final llamado es
                <code>RoadmapController::componentsAction()</code>
                .
            </para>

            <para>
                Continuando, creemos ahora un action controller
                y un método de acción por defecto. Como se ha dicho antes,
                el controlador por defecto y la acción llamada son ambos
                <code>index</code>
                . Abra el archivo
                <code>application/controllers/IndexController.php</code>
                , e introduzca lo siguiente:
            </para>

            <programlisting role="php"><![CDATA[
/** Zend_Controller_Action */
class IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
    }
}
]]></programlisting>

            <para>
                Por defecto, el action helper
                <link linkend="zend.controller.actionhelpers.viewrenderer">
                    ViewRenderer
                </link>
                está activado. Esto significa que simplemente
                definiendo un action method y un view script correspondiente,
                tendrá su contenido generado inmediatamente.
                Por defecto,
                <code>Zend_View</code>
                es usado como la capa Vista en el patrón MVC. El
                <code>ViewRenderer</code>
                hace algo de magia, y usa el nombre de controlador (e.g.,
                <code>index</code>
                ) y el nombre de acción actual (e.g.,
                <code>index</code>
                ) para determinar qué plantilla traer. Por defecto,
                las plantillas terminan con la extensión
                <code>.phtml</code>
                , lo que significa que en el ejemplo de arriba, la
                plantilla
                <code>index/index.phtml</code>
                será generada. Adicionalmente, el
                <code>ViewRenderer</code>
                asume automáticamente que la carpeta
                <code>views</code>
                al mismo nivel que la carpeta controller será
                la carpeta raíz de la vista, y que el script de vista actual
                estará en la subcarpeta
                <code>views/scripts/</code>.
                De esta forma, la plantilla generada será encontrada en
                <code>application/views/scripts/index/index.phtml</code>
                .
            </para>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.view">
            <title>Cree su view script</title>

            <para>
                Como hemos mencionado
                <link linkend="zend.controller.quickstart.go.controller">
                    en la sección anterior
                </link>
                , los scripts de vista se encuentran en
                <code>application/views/scripts/</code>
                ; el view script para el controlador y la acción por defecto
                está en
                <code>application/views/scripts/index/index.phtml</code>
                . Cree este archivo, y escriba un poco de HTML:
            </para>

            <programlisting role="php"><![CDATA[
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Mi primera aplicación Zend Framework</title>
</head>
<body>
    <h1>>¡Hola, Mundo!</h1>
</body>
</html>
]]></programlisting>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.errorhandler">
            <title>Cree su controlador de errores</title>

            <para>
                Por defecto, está registrado
                <link linkend="zend.controller.plugins.standard.errorhandler">
                    el plugin 'error handler'
                </link>. Este plugin espera que exista
                un controlador para manejar los errores.
                Por defecto, asume un
                <code>ErrorController</code>
                en el módulo default con un método
                <code>errorAction</code>
                :
            </para>

            <programlisting role="php"><![CDATA[
class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
    }
}
]]></programlisting>

            <para>
                Asumiendo el sistema de carpetas discutido anteriormente,
                este archivo irá en
                <code>application/controllers/ErrorController.php</code>
                . También necesitará crear un view script en
                <code>application/views/scripts/error/error.phtml</code>
                ; el contenido de ejemplo será parecido a:
            </para>

            <programlisting role="php"><![CDATA[
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Error</title>
</head>
<body>
    <h1>Ocurrió un error</h1>
    <p>Ocurrió un error; Por favor, inténtelo de nuevo más tarde.</p>
</body>
</html>
]]></programlisting>
        </sect3>

        <sect3 id="zend.controller.quickstart.go.finish">
            <title>¡Vea el sitio!</title>

            <para>
                Con su primer controlador y vista, ya puede arrancar su navegador y acceder a su sitio.
                Asumiendo que
                <code>example.com</code>
                es su dominio, cualquiera de las siguientes URLs le llevará a
                la página que acaba de crear:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <code>http://example.com/</code>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>http://example.com/index</code>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <code>http://example.com/index/index</code>
                    </para>
                </listitem>
            </itemizedlist>

            <para>
                Ya está listo para empezar a crear más métodos de controladores y acciones. ¡Felicidades!
            </para>
        </sect3>
    </sect2>
</sect1>
<!--
    vim:se ts=4 sw=4 et:
-->