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

<?xml version="1.0" encoding="UTF-8"?>
    <!-- EN-Revision: 24249 -->
    <!-- Reviewed: no -->
<sect1 id="zend.controller.quickstart">
    <title>Inicio rápido a Zend_Controller</title>

    <sect2 id="zend.controller.quickstart.introduction">
        <title>Introducción</title>
        <para>
            <classname>Zend_Controller</classname>
            es el corazón del sistema de
            <acronym>MVC</acronym>
            de Zend Framework
            <acronym>MVC</acronym>
            .
            <acronym>MVC</acronym>
            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.
            <classname>Zend_Controller_Front</classname>
            implementa el patrón
            <ulink url="http://www.martinfowler.com/eaaCatalog/frontController.html">
                Front Controller (Controlador Frontal)
            </ulink>
            en el cual todas las transacciones
            <acronym>HTTP</acronym>
            (requests) son
            interceptadas por el controlador frontal y enviado a una
            Acción particular
            de un Controlador según la
            <acronym>URL</acronym>
            pedida.

        </para>
        <para>
            El sistema
            <classname>Zend_Controller</classname>
            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 language="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 el document root</title>

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

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

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

            <programlisting language="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>

            <note>
                <title>Learn about mod_rewrite</title>

                <para>
                    The above rewrite rules allow access to any file under your
                    virtual host's
                    document root. If there are files you do not
                    want exposed in this way, you may
                    want to be more
                    restrictive in your rules. Go to the Apache website to
                    <ulink url="http://httpd.apache.org/docs/2.0/mod/mod_rewrite.html">learn
                        more about mod_rewrite</ulink>
                    .
                </para>
            </note>

            <para>
                If using
                <acronym>IIS</acronym>
                7.0, use the following as your rewrite
                configuration:
            </para>

            <programlisting language="xml"><![CDATA[
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
     <system.webServer>
         <rewrite>
             <rules>
                 <rule name="Imported Rule 1" stopProcessing="true">
                     <match url="^.*$" />
                     <conditions logicalGrouping="MatchAny">
                         <add input="{REQUEST_FILENAME}"
                             matchType="IsFile" pattern=""
                             ignoreCase="false" />
                         <add input="{REQUEST_FILENAME}"
                             matchType="IsDirectory"
                             pattern="" ignoreCase="false" />
                     </conditions>
                     <action type="None" />
                 </rule>
                 <rule name="Imported Rule 2" stopProcessing="true">
                     <match url="^.*$" />
                     <action type="Rewrite" url="index.php" />
                 </rule>
             </rules>
         </rewrite>
     </system.webServer>
</configuration>
]]></programlisting>

            <para>
                La regla de arriba redirigirá 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>Crear el archivo bootstrap</title>

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

            <programlisting language="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>Crear el 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
                <acronym>URL</acronym>
                apunta
                a un controlador, y el segundo a una acción. Por ejemplo,
                dada la
                <acronym>URL</acronym>
                <filename>
                    http://framework.zend.com/roadmap/components
                </filename>
                , la ruta es
                <filename>/roadmap/components</filename>
                , que apuntará al controlador
                <emphasis>roadmap</emphasis>
                y la acción
                <emphasis>components</emphasis>
                . Si no se suministra una acción, se asume la acción
                <emphasis>index</emphasis>
                , y si no se suministra un controlador, se asume el controlador
                <emphasis>index</emphasis>
                (siguiendo la convención de Apache de apuntar a
                <emphasis>DirectoryIndex</emphasis>
                automáticamente).
            </para>

            <para>
                El dispatcher de
                <classname>Zend_Controller</classname>
                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
                <emphasis>Controller</emphasis>
                . De esta forma, en nuestro ejemplo de arriba, el controlador
                <emphasis>roadmap</emphasis>
                es dirigido a la clase
                <classname>RoadmapController</classname>
                .
            </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
                <emphasis>Action</emphasis>
                es añadida. De esta forma, en nuestro ejemplo de arriba, la acción
                <emphasis>components</emphasis>
                se convierte en
                <emphasis>componentsAction</emphasis>
                , y el método final llamado es
                <methodname>RoadmapController::componentsAction()</methodname>
                .
            </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
                <emphasis>index</emphasis>
                . Abra el archivo
                <filename>application/controllers/IndexController.php</filename>
                , e introduzca lo siguiente:
            </para>

            <programlisting language="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,
                <classname>Zend_View</classname>
                es usado como la capa Vista en el patrón
                <acronym>MVC</acronym>
                . El
                <emphasis>ViewRenderer</emphasis>
                hace algo de magia, y usa el nombre de controlador (e.g.,
                <emphasis>index</emphasis>
                ) y el nombre de acción actual (e.g.,
                <emphasis>index</emphasis>
                ) para determinar qué plantilla traer. Por defecto,
                las plantillas terminan con la
                extensión
                <filename>.phtml</filename>
                , lo que significa que en el ejemplo de arriba, la
                plantilla
                <filename>index/index.phtml</filename>
                será generada. Adicionalmente, el
                <emphasis>ViewRenderer</emphasis>
                asume automáticamente que la carpeta
                <emphasis>views</emphasis>
                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
                <filename>views/scripts/</filename>
                .
                De esta forma, la plantilla generada será encontrada en
                <filename>application/views/scripts/index/index.phtml</filename>
                .
            </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
                <filename>application/views/scripts/</filename>
                ; el view script para el controlador y la acción por defecto
                está en
                <filename>application/views/scripts/index/index.phtml</filename>
                . Cree este archivo, y escriba un poco de HTML:
            </para>

            <programlisting language="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
                <emphasis>ErrorController</emphasis>
                en el módulo default con un método
                <methodname>errorAction()</methodname>
                :
            </para>

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

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

            <programlisting language="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
                <filename>example.com</filename>
                es su dominio, cualquiera de las siguientes
                <acronym>URL</acronym>
                s le llevará a
                la página que acaba de crear:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        <filename>http://example.com/</filename>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <filename>http://example.com/index</filename>
                    </para>
                </listitem>
                <listitem>
                    <para>
                        <filename>http://example.com/index/index</filename>
                    </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:
-->