<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 24249 -->
<!-- Reviewed: no -->
<sect1 id="learning.quickstart.create-project">
    <title>Créer votre projet</title>

    <para>
        Afin de créer un projet, vous devez d'abord télécharger et extraire Zend Framework.
    </para>

    <sect2 id="learning.quickstart.create-project.install-zf">
        <title>Installer Zend Framework</title>

        <para>
            La manière la plus simple d'obtenir Zend Framework avec une pile <acronym>PHP</acronym>
            complète est d'installer <ulink url="http://www.zend.com/en/products/server-ce/downloads">
            Zend Server</ulink>. Zend Server possède des installeurs natifs pour Mac OSX, Windows, Fedora Core,
            et Ubuntu, ainsi qu'un installeur universel pour la plupart des distributions Linux.
        </para>

        <para>
            Après avoir installé Zend Server, les fichiers du Framework devraient se trouver sous
            <filename>/usr/local/zend/share/ZendFramework</filename> sur Mac OSX et Linux,
            et <filename>C:\Program Files\Zend\ZendServer\share\ZendFramework</filename> sur
            Windows. L'<constant>include_path</constant> aura déja été configuré pour inclure
            Zend Framework.
        </para>

        <para>
            Il reste bien sûr possible <ulink url="http://framework.zend.com/download/latest"> de télécharger
            la dernière version de Zend Framework</ulink> et l'extraire; notez simplement où vous choisissez
            de l'extraire.
        </para>

        <para>
            Optionellement, vous pouvez ajouter le chemin vers le sous-dossier <filename>library/</filename>
            de l'archive à l'<constant>include_path</constant> de votre <filename>php.ini</filename>.
        </para>

        <para>
            Ca y est! Zend Framework est maintenant installé et prêt à l'emploi.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.create-project">
        <title>Créer votre projet</title>

        <note>
            <title>Outil en ligne de commandes zf</title>

            <para>
                Dans la dossier <filename>bin/</filename> de votre installation de Zend Framework
                se trouvent les scripts <filename>zf.sh</filename> et <filename>zf.bat</filename>
                pour Unix et Windows respectivement. Notez le chemin absolu vers ces fichiers.
            </para>

            <para>
                Partout ou vous voyez uyne référence à la commande <command>zf</command>, utilisez le chemin
                absolu du script. Sur les système Unix, vous pouvez utiliser la fonctionnalité d'alias dans le
                shell: <command>alias zf.sh=path/to/ZendFramework/bin/zf.sh</command>.
            </para>

            <para>
                Si vous avez des problèmes pour configurer la commande <command>zf</command>, veuillez vous
                référer <link linkend="zend.tool.framework.clitool">au manuel</link>.
            </para>
        </note>

        <para>
            Ouvrez un terminal (sous Windows, <command>Démarrer -> Exécuter</command>, puis
            <command>cmd</command>). Naviguez vers un dossier dans lequel vous souhaitez démarrer un projet.
            Puis, utilisez le chemin vers le script approprié et lancez:
        </para>

        <programlisting language="shell"><![CDATA[
% zf create project quickstart
]]></programlisting>

        <para>
            Cette commande crée un projet avec une structure basique incluant des contrôleurs et vues.
            L'arbre va ressembler à ceci:
        </para>

        <programlisting language="text"><![CDATA[
quickstart
|-- application
|   |-- Bootstrap.php
|   |-- configs
|   |   `-- application.ini
|   |-- controllers
|   |   |-- ErrorController.php
|   |   `-- IndexController.php
|   |-- models
|   `-- views
|       |-- helpers
|       `-- scripts
|           |-- error
|           |   `-- error.phtml
|           `-- index
|               `-- index.phtml
|-- library
|-- public
|   |-- .htaccess
|   `-- index.php
`-- tests
    |-- application
    |   `-- bootstrap.php
    |-- library
    |   `-- bootstrap.php
    `-- phpunit.xml
]]></programlisting>

        <para>
            Dès lors si vous n'avez pas ajouté Zend Framework à votre
            <constant>include_path</constant>, nous vous recommandons de copier ou lier celui-ci dans
            le dossier <filename>library/</filename> de votre projet. Dans ce cas vous devriez copier
            récursivement (ou lier) <filename>library/Zend/</filename> de l'installation de
            Zend Framework vers le dossier <filename>library/</filename> de votre projet. Sur les
            systèmes Unix cela peut être effectué de la manière suivante:
        </para>

        <programlisting language="shell"><![CDATA[
# Symlink:
% cd library; ln -s path/to/ZendFramework/library/Zend .

# Copy:
% cd library; cp -r path/to/ZendFramework/library/Zend .
]]></programlisting>

        <para>
            Sur Windows le plus simple sera d'utiliser l'explorateur.
        </para>

        <para>
            Maintenant que le projet est crée, les principaux points à comprendre sont le
            bootstrap, la configuration, les contrôleurs d'action et les vues.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.bootstrap">
        <title>Le Bootstrap</title>

        <para>
            Votre classe <classname>Bootstrap</classname> définit les ressources (composants) à
            initialiser. Par défaut, le <link linkend="zend.controller.front">contrôleur frontal
            </link> est initialisé et il utilise <filename>application/controllers/</filename>
            comme dossier de contrôleurs par défaut (nous reverrons cela). La classe ressemble à:
        </para>

        <programlisting language="php"><![CDATA[
// application/Bootstrap.php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}
]]></programlisting>

        <para>
            Comme vous le voyez, rien de plus n'est nécessaire pour commencer.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.configuration">
        <title>Configuration</title>

        <para>
            Le Zend Framework lui-même n'a pas besoin de configuration, mais l'application oui. La
            configuration par défaut est placée sous
            <filename>application/configs/application.ini</filename> et contient des directives de base
            pour régler l'environnement <acronym>PHP</acronym> (par exemple, activer ou désactiver le
            rapport d'erreurs), indiquer le chemin vers votre classe de bootstrap (ainsi que son nom)
            , et le chemin vers les contrôleurs d'action. Cela ressemble à:
        </para>

        <programlisting language="ini"><![CDATA[
; application/configs/application.ini

[production]
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

[staging : production]

[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
]]></programlisting>

        <para>
            Plusieurs choses sont à connaitre concernant ce fichier. D'abord, si vous utilisez une
            configuration basée sur des fichiers <acronym>INI</acronym>, vous pouvez faire usage des
            constantes directement; <constant>APPLICATION_PATH</constant> est ici une constante. Aussi,
            notez que plusieurs sections ont été définies: production, staging, testing, et
            development. Les trois dernières héritent de la section "production". C'est une manière utile
            d'organiser sa configuration et de s'assurer que les paramètres appropriés sont utilisés
            pour chaque étape du développement de l'application.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.action-controllers">
        <title>Contrôleurs d'action</title>

        <para>
            Les <emphasis>contrôleurs d'action</emphasis> de votre application contiennent la logique 'utile'
            de celle-ci et font correspondre les requêtes aux bons modèles et aux bonnes vues.
        </para>

        <para>
            Un contrôleur d'action devrait posséder une ou plusieurs méthodes se terminant par
            "Action"; ces méthodes sont interrogées via le web. Par défaut, les URLs de Zend
            Framework suivent le schéma <constant>/controller/action</constant>, où
            "controller" correspond à la classe de contrôleur (sans le suffixe "Controller")
            et "action" correspond à la méthode d'action (sans le suffixe "Action").
        </para>

        <para>
            Typiquement, vous aurez toujours besoin d'un <classname>IndexController</classname>,
            qui est utilisé par défaut et servira aussi la page d'accueil, et un
            <classname>ErrorController</classname>, utilisé pour indiquer les erreurs
            <acronym>HTTP</acronym> 404 (contrôleur ou action introuvable) et les erreurs
            <acronym>HTTP</acronym> 500 (erreurs de l'application).
        </para>

        <para>
            <classname>IndexController</classname> par défaut est défini comme suit:
        </para>

        <programlisting language="php"><![CDATA[
// application/controllers/IndexController.php

class IndexController extends Zend_Controller_Action
{

    public function init()
    {
        /* Initialisez le contrôleur et l'action ici */
    }

    public function indexAction()
    {
        // corps de l'action
    }
}
]]></programlisting>

        <para>
            <classname>ErrorController</classname> par défaut est défini comme suit:
        </para>

        <programlisting language="php"><![CDATA[
// application/controllers/ErrorController.php

class ErrorController extends Zend_Controller_Action
{

    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) {
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

                // 404 error -- controller or action not found
                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Page not found';
                break;
            default:
                // application error
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = 'Application error';
                break;
        }

        $this->view->exception = $errors->exception;
        $this->view->request   = $errors->request;
    }
}
]]></programlisting>

        <para>
            Notez que (1) <classname>IndexController</classname> ne contient pas de code réel,
            et (2) <classname>ErrorController</classname> référence un attribut "view".
            Ceci nous mène vers la section suivante.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.views">
        <title>Vues</title>

        <para>
            Les vues dans Zend Framework sont écrites en <acronym>PHP</acronym> classique. Les scripts
            de vues sont placés sous <filename>application/views/scripts/</filename>, ils sont
            référencés plus tard dans les contrôleurs. Dans notre cas, nous avons un
            <classname>IndexController</classname> et un <classname>ErrorController</classname>,
            et nous avons ainsi des dossiers <filename>index/</filename> et
            <filename>error/</filename> correspondants dans le dossier scripts des vues. Dans ces
            dossiers, vous trouverez ou créerez des scripts de vue correspondants aux actions
            exposées par les contrôleurs; dans le cas par défaut nous avons ainsi des scripts de
            vue <filename>index/index.phtml</filename> et <filename>error/error.phtml</filename>.
        </para>

        <para>
            Les scripts de vue peuvent contenir le code de présentation que vous voulez et utiliser
            les tags <emphasis>&lt;?php</emphasis> ou <emphasis>?&gt;</emphasis> pour insérer du
            <acronym>PHP</acronym>.
        </para>

        <para>
            Ce qui suit présente le code par défaut de <filename>index/index.phtml</filename>:
        </para>

        <programlisting language="php"><![CDATA[
<!-- application/views/scripts/index/index.phtml -->
<style>

    a:link,
    a:visited
    {
        color: #0398CA;
    }

    span#zf-name
    {
        color: #91BE3F;
    }

    div#welcome
    {
        color: #FFFFFF;
        background-image: url(http://framework.zend.com/images/bkg_header.jpg);
        width:  600px;
        height: 400px;
        border: 2px solid #444444;
        overflow: hidden;
        text-align: center;
    }

    div#more-information
    {
        background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
        height: 100%;
    }

</style>
<div id="welcome">
    <h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
    <h3>This is your project's main page<h3 />
    <div id="more-information">
        <p>
            <img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
        </p>

        <p>
            Helpful Links: <br />
            <a href="http://framework.zend.com/">Zend Framework Website</a> |
            <a href="http://framework.zend.com/manual/en/">Zend Framework
                Manual</a>
        </p>
    </div>
</div>
]]></programlisting>

        <para>
            Le script de vue <filename>error/error.phtml</filename> est plus intéréssant car il
            inclut des conditions écrites en <acronym>PHP</acronym>:
        </para>

        <programlisting language="php"><![CDATA[
<!-- application/views/scripts/error/error.phtml -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Zend Framework Default Application</title>
</head>
<body>
  <h1>An error occurred</h1>
  <h2><?php echo $this->message ?></h2>

  <?php if ('development' == $this->env): ?>

  <h3>Exception information:</h3>
  <p>
      <b>Message:</b> <?php echo $this->exception->getMessage() ?>
  </p>

  <h3>Stack trace:</h3>
  <pre><?php echo $this->exception->getTraceAsString() ?>
  </pre>

  <h3>Request Parameters:</h3>
  <pre><?php echo var_export($this->request->getParams(), 1) ?>
  </pre>
  <?php endif ?>

</body>
</html>
]]></programlisting>
    </sect2>

    <sect2 id="learning.quickstart.create-project.vhost">
        <title>Creation d'un hôte virtuel</title>

        <para>
            Pour le quickstart nous supposerons que vous utilisez le <ulink
                url="http://httpd.apache.org/">serveur web Apacher</ulink>. Zend Framework fonctionne
                très bien avec d'autres serveurs -- y compris Microsoft Internet Information
            Server, lighttpd, nginx, et plus -- mais la plupart des développeurs devraient être familiers
            à Apache, et cela permet d'introduire la structure de dossiers de Zend Framework et les
            capacités de réécriture.
        </para>

        <para>
            Pour créer un vhost, vous devez connaitre l'emplacement du fichier
            <filename>httpd.conf</filename>, et les emplacements des autres fichiers de configuration
            protenciels. Voici quelques emplacements classiques:
        </para>

        <itemizedlist>
            <listitem>
                <para>
                    <filename>/etc/httpd/httpd.conf</filename> (Fedora, RHEL, et autres)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>/etc/apache2/httpd.conf</filename> (Debian, Ubuntu, et autres)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>/usr/local/zend/etc/httpd.conf</filename> (Zend Server sur *nix)
                </para>
            </listitem>

            <listitem>
                <para>
                    <filename>C:\Program Files\Zend\Apache2\conf</filename> (Zend Server sur Windows)
                </para>
            </listitem>
        </itemizedlist>

        <para>
            Au sein de <filename>httpd.conf</filename> (ou <filename>httpd-vhosts.conf</filename>
            sur certains systèmes), vous aurez besoin de deux choses. D'abord s'assurer que
            <varname>NameVirtualHost</varname> est défini; typiquement à une valeur de "*:80".
            Ensuite, définir les hôtes virtuels:
        </para>

        <programlisting language="apache"><![CDATA[
<VirtualHost *:80>
    ServerName quickstart.local
    DocumentRoot /path/to/quickstart/public

    SetEnv APPLICATION_ENV "development"

    <Directory /path/to/quickstart/public>
        DirectoryIndex index.php
        AllowOverride All
        Order allow,deny
        Allow from all
    </Directory>
</VirtualHost>
]]></programlisting>

        <para>
            Notons plusieurs points. D'abord le <varname>DocumentRoot</varname> pointe vers le dossier
            <filename>public</filename> du projet; ceci signifie que seuls les fichiers sous cette
            arborescence peuvent être servis directement par le serveur. Ensuite,
            <varname>AllowOverride</varname>, <varname>Order</varname>, et
            <varname>Allow</varname>; ces directives servent à autoriser l'utilisation de fichiers
            <filename>htacess</filename> dans le projet. Pendant le développement, c'est une bonne
            pratique car ça évite de redémarrer sans arrêt le serveur dès qu'un changement y est opéré;
            cependant en production le contenu de <filename>htaccess</filename> devrait être reproduit
            dans la configuration puis désactivé. Enfin notez <varname>SetEnv</varname>. Ici nous
            renseignons une variable d'environnement pour l'hôte virtuel, celle-ci sera récupérée
            dans <filename>index.php</filename> et utilisée pour affecter la constante
            <constant>APPLICATION_ENV</constant> de l'application Zend Framework. En
            production, vous pouvez oublier cette directive (dans un tel cas la valeur par défaut sera
            "production") ou la préciser explicitement à la valeur "production".
        </para>

        <para>
            Finalement, vous devrez ajouter une entrée au DNS ou au fichier d'hôtes
            (<filename>hosts</filename>) pour la valeur de <varname>ServerName</varname>. Sur les
            systèmes *nix, il s'agit de <filename>/etc/hosts</filename>; sur Windows, vous trouverez
            normalement ce fichier sous <filename>C:\WINDOWS\system32\drivers\etc</filename>. Quel que
            soit le système, l'entrée sera de la forme:
        </para>

        <programlisting language="text"><![CDATA[
127.0.0.1 quickstart.local
]]></programlisting>

        <para>
            Démarrez votre serveur web (ou redémarrez le), et tout devrait être prêt.
        </para>
    </sect2>

    <sect2 id="learning.quickstart.create-project.checkpoint">
        <title>Checkpoint</title>

        <para>
            Dès lors, vous devriez pouvoir démarrer votre application Zend Framework. Faites pointer votre
            navigateur vers l'hôte configuré dans la section précédente et une page d'accueil devrait
            s'afficher.
        </para>
    </sect2>
</sect1>
