LyRiX Blog, tutos sur le Zend Framework, php et autre techno Web

Symfony2: How to mock services during functional tests

2013-04-12T00:00:00+02:00

When you are working with web-service and you want to add some tests, you have two options:

Use the real service
Mock the service

The first one has some advantages: If the web-service change, your tests will fail. And it has some inconvenience: If the web-service is momently down, your tests fail.

But sometime, you really want to mock these services to perform some extra tests, such as emulate a service down, etc...

With Symfony2 you have some options to mock a web-service.

The first one is to use a mock class for test environment. Here, we assume you have created a Symfony2 service (think DIC) to wrap the web-service.

The first option is to change the service through the configuration in app/config/config_test.yml. So you may have something like this in your src/MyBundle/Resources/config/services.xml:

<parameters>
    <parameter key="my_bundle.twitter.class">Twitter</parameter>
</parameters>

<services>
    <service id="my_bundle.twitter" class="%my_bundle.twitter.class%">
    </service>
<services>

and so the config_test.yml

parameters:
    my_bundle.twitter.class: TwitterMock

This option is not very flexible because we can emulate a service down, ...

So the second option is to replace the service by a phpunit mock. To do that, we have to change during the runtime a Symfony2 service. But this is not so easy, because symfony will shutdown and re-boot your kernel between each request (see here).

So the idea is to override the Kernel to allow the developer to execute some code after the boot call. So we start to create a new kernel:

<?php

// app/AppTestKernel.php

require_once __DIR__.'/AppKernel.php';

class AppTestKernel extends AppKernel
{
    private $kernelModifier = null;

    public function boot()
    {
        parent::boot();

        if ($kernelModifier = $this->kernelModifier) {
            $kernelModifier($this);
            $this->kernelModifier = null;
        };
    }

    public function setKernelModifier(\Closure $kernelModifier)
    {
        $this->kernelModifier = $kernelModifier;

        // We force the kernel to shutdown to be sure the next request will boot it
        $this->shutdown();
    }
}

And now, we can alter the kernel during the test:

class TwitterTest extends WebTestCase
{
    public function testTwitter()
    {
        $twitter = $this->getMock('Twitter');
        // Configure your mock here.
        static::$kernel->setKernelModifier(function($kernel) use ($twitter) {
            $kernel->getContainer()->set('my_bundle.twitter', $twitter);
        });

        $this->client->request('GET', '/fetch/twitter'));

        $this->assertSame(200, $this->client->getResponse()->getStatusCode());
    }
}

And thats it ;)

What my sismo configuration looks like?

2013-02-07T00:00:00+01:00

Sismo is a Continuous Testing Server written in PHP. I build all projects I'm working on with it.

It's very fast to set up a newproject, but it's a little but boring. So I want to share my ~/.sismo/config.php and a little script to set-up a new project.

<?php

// ~/.sismo/config.php

Sismo\Project::setDefaultCommand('if [ -f composer.json ]; then composer install --dev; fi && phpunit');

$notifier = new Sismo\Notifier\DBusNotifier();

$sfCommand = <<<'EOL'
cp app/config/parameters.yml-dist app/config/parameters.yml

sed -i -e "s/database_user:.*/database_user: greg/" app/config/parameters.yml
sed -i -e "s/database_password:.*/database_password: ~/" app/config/parameters.yml

./bin/run-tests.sh
EOL;

$projects = array(
    (new Sismo\Project(ucfirst('monolog'), '/home/greg/dev/labs/monolog', $notifier)),
    (new Sismo\Project('Project FOO', '/home/greg/dev/project/foo', $notifier))->setCommand($sfCommand),
    // ...
);

return $projects;

And then the little script to set up the post commit hook and config.php.

Put this command in your $PATH (like /usr/local/bin/sismo-add)
Adapt the SISMO_PATH
Then call it from a git project that you want to test with sismo

The script:

#!/bin/bash

SISMO_PATH=$HOME/dev/labs/sismo/sismo

#/usr/local/bin/sismo-add

######################################
# Do not change code after this line #
######################################

BASE_PATH=`pwd`
SLUG=`basename $BASE_PATH`

cat > $BASE_PATH/.git/hooks/post-commit <<EOL
#!/bin/bash

$SISMO_PATH build $SLUG \`git log -1 HEAD --pretty="%H"\` --force --quiet &
EOL

chmod +x $BASE_PATH/.git/hooks/post-commit

SISMO_PROJECT="    (new Sismo\\\\Project(ucfirst('$SLUG'), '$BASE_PATH', \$notifier)),"

sed -ie "s#\(\$projects = array(\)#\1\n$SISMO_PROJECT#" $HOME/.sismo/config.php

How to open a file with sublime text from your browser

2013-02-05T00:00:00+01:00

Note: This work only with ubuntu.

Why?

If you are doing some php with sublime text 2, this tips will enjoy your day. You can configure your system (ubuntu, may be other other distro too) to handle links like subl:///tmp/file.txt?10 to open the file /tmp/file.txt with sublime text 2 at the line 10. To do that, you have to register a new protocol handler, and to configure xdebug.

When did it happend ? When a fatal error or an exception is throwed by php:

With this tip /opt/dotefiles/www/fail.php is clickable.

Note: If you are using symfony2 all files in an exception page, or the web developper toolbar will be clickable!!!

How?

Start by editing ~/.local/share/applications/mimeapps.list:

[Added Associations]
# ...
x-scheme-handler/subl=subl-urlhandler.desktop

Then create the file /usr/share/applications/subl-urlhandler.desktop. (This is a fake application):

[Desktop Entry]
Version=1.0
Name=Sublime Text 2
Name[en_PH]=Sublime Text 2
Exec=xdebug-urlhandler %u
Icon=/opt/subl/Icon/48x48/sublime_text.png
Terminal=false
Type=Application
Categories=Development;
StartupNotify=true
MimeType=x-scheme-handler/subl;

And then create the file /usr/local/bin/xdebug-urlhandler:

#!/bin/bash

url=$1
file=${url#subl*//}
path=`echo $file | cut -d? -f 1`
line=`echo $file | cut -d? -f 2`
sublime-text $path:$line

You should run:

sudo chmod +x /usr/local/bin/xdebug-urlhandler

And now you have to configure xdebug /etc/php5/conf.d/90-my.ini:

[PHP]
xdebug.file_link_format=subl://%f?%l

Thinks to restart apache or php-fpm. Enjoy

Source

Symfony2: How to debug your functionals tests

2013-02-03T00:00:00+01:00

When you write functional tests with symfony2 and phpunit, it could be hard to debug them if an exception happened. You can try to var_dump the response, but since you ran tests from cli, the output is totally unreadable.

So there is a very usefull way to view what happening. You should add echo $this->client->getReponse()->getContent();die;:

namespace MyBundle\Tests\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;

class UserControllerTest extends WebTestCase
{
    public function testRegister()
    {
        $this->client->request('GET', '/register');

        echo $this->client->getReponse()->getContent();die;// Just add this line

        // Perform some test
        // $this->assertOk($this->client);
        // ...
    }
}

And then run your test:

phpunit --filter testRegister path/to/the/test/UserControllerTest.php > web/debug.html

And now, you can browse http://yourpoject.localhost/debug.html with your favorite browser.

Symfony2: Snippet to render all form errors

2013-01-31T00:00:00+01:00

With symfony 2, you can render all errors from a form with a little macro. You can use it for only one form, or for all your application

The macro

{# MyBundle:form.html.twig #}

{% macro display_error(form) %}
    {% import _self as forms %}
    <ul>
        {% for child in form if not child.vars.valid %}
            <li>
                {% if child.vars.compound and not child.vars.valid %}
                    {{ child.vars.label|trans|capitalize }}:
                    {{ forms.display_error(child) }}
                {% else %}
                    <h5>
                        <a href="#{{ child.vars.id }}">
                            {{ child.vars.label|trans|capitalize }}:
                        </a>
                        <small>
                            {% for error in child.vars.errors %}
                                {{ error.message|capitalize }}
                            {% endfor %}
                        </small>
                    </h5>
                {% endif %}
            </li>
        {% endfor %}
    </ul>
{% endmacro %}

Usage

Just for one form:

{# MyBundle:User:new.html.twig #}

{% import "MyBundle:form.html.twig" as macros %}

{% if not form.vars.valid %}
    <!-- Wep, this is some twitter bootstrap markup -->
    <div class="alert alert-block alert-error">
        <button type="button" class="close" data-dismiss="alert">&times;</button>
        <h3>Oh snap!</h3>
        <p><strong>Change a few things up and try submitting again.</strong></p>
        {{ macros.display_project_error(form) }}
    </div>
{% endif %}

For all you application

Add the layout in your config.yml:

twig:
    form:
        resources:
            - MyBundle::form_div_layout.html.twig

And override the form_errors block:

{# form_div_layout.html.twig #}

{% block form_errors %}
{% spaceless %}
    {% import "MyBundle:form.html.twig" as macros %}
    {% if not form.parent and not form.vars.valid %}
         {% import _self as forms %}
        <div class="alert alert-block alert-error">
            <button type="button" class="close" data-dismiss="alert">&times;</button>
            <h3>Oh snap!</h3>
            <p><strong>Change a few things up and try submitting again.</strong></p>
            {{ macros.display_project_error(form) }}
        </div>
    {% else %}
        {{ parent() }}
    {% endif %}
{% endspaceless %}
{% endblock %}

Sublime text 2 et xdebug : liens cliquables sur les fichiers

2012-02-23T00:00:00+01:00

Salut,

Si comme moi vous utilisez sublime text 2 pour développer, vous allez apprécier ce petit tips. Par exemple quand vous avez une erreur 500 et / ou une fatal erreur, xdebug vous affiche la backtrace avec le nom des fichiers. Grâce a ce hacks, il est possible d’ouvrir directement dans sublimetext le fichier correspondant.

Configuration de Xdebug :

dans le fichier xdebug.ini (ou directement dans php.ini) il faut ajouter la ligne suivante :

xdebug.file_link_format=sblm://%f?%l

Puis redémarrer apache ou php-fpm …

Configuration de sublime text

Il faut ajouter ce package dans la liste des packages. Il suffit de dézipper le contenue de l’archive dans le dossier package de sublime text 2, disponssible via le menu « Preference > Browse Package »

Et voila le tours est joué ;)

Attention

Cela ne marche pour l’instant que sur windows. Je pense que c’est assez simple de faire la meme choses pour linux.

Source

Mysql + export + csv + groupy en gardant les colonnes groupées

2012-02-01T00:00:00+01:00

Petit tips avec MySQL. Admettons que vous voulez faire un export en csv d’une table (A). Dans ce cas, c’est facile, il suffit d’utiliser « INTO OUTFILE ». Par contre, si vous avez une jointure (A -> B), c’est plus compliqué.

Il y a plusieurs solutions : soit on se retrouve avec plusieurs ligne de la table A en double, puis à « droite » de ces lignes , les colonnes de la table B.

Soit on utilise la fonction group_concat; et un petit hack ;)

Exemple :

SELECT c.id, c.first_name, c.last_name, GROUP_CONCAT(CONCAT(p.bar_code, '||', p.quantity, '||', p.date) SEPARATOR "||")
    FROM contact c
    LEFT JOIN product p on (c.id = p.contact_id)
    GROUP BY c.id
    INTO OUTFILE '/tmp/export.csv' FIELDS TERMINATED BY ';' OPTIONALLY ENCLOSED BY '"'
;

On fait notre jointure normalement, on group by sur c.id, et c’est dans le select qu’il y a une peu de magie. On va d’abord concaténer les attributs de la table « product » avec comme séparateur deux pipes « || ». Et ensuite, on va concaténer toutes les valeurs résultantes de la fonction GROUP BY.

Enfin, il va falloir remplacer tous nos doubles pipes (||) par ; qui correspond a nos délimiteurs de champs.

sed -i 's/||/";"/g' /tmp/export.csv

Et voila, vous avec un beau fichier CSV bien formaté ;) Ici le hack c’est de remplacer un délimiteur un peu spécial « || » par un vrai délimiteur, a posteriori.

P.S. : Il se peut que mysql exporte le fichier csv avec l’utilisateur mysql. Vous n’aurez donc pas les droits pour le lire et/ou le modifier. Il faut donc passer en root ;).

Silex Kitchen Edition

2011-10-24T00:00:00+02:00

Silex est un micro-framework (en php) basé sur les composants symfony2. Je vous invite à aller voir la documentation. Elle est déjà très bien fournie.

Cependant, si vous voulez débuter avec silex, je vous propose une édition avec une achitecture déjà mise en place, qui respecte les bonnes pratiques. On y retrouve les services suivants: sessions, cache, twig, assetic, doctrine, translation, form, test. De plus, elle est packagé avec twitter bootstrap.

Je vous invite à lire la doc ou à la télécharger sur github

Lister ses films

2011-06-05T00:00:00+02:00

Un petit script bash (donc pour linux/mac) pour lister tous les films qui peuvent trainer dans plusieurs répertoires et sous répertoires…

wget https://gist.github.com/raw/1008082/dc6cdb8ae50bd981ae9458cc270f96de41583718/movieList.sh
chmod +x movieList.sh
# Configure VIDEO_FOLDER
./movieList.sh
cat movie_list.txt

Script :

#!/bin/bash

VIDEO_FOLDER=(
  /PATH/TO/MOVIE1
  /PATH/TO/MOVIE2
)
VIDEO_EXTENTION=(avi mkv mpg mpeg)

OUTPUT='movie_list.txt'
OUTPUT_TEMP=${OUTPUT}.temp

`>$OUTPUT_TEMP`

for folder in "${VIDEO_FOLDER[@]}"
do
  if [ -d $folder ]; then
      for ext in "${VIDEO_EXTENTION[@]}"
      do
        find $folder -iname "*.$ext" >> $OUTPUT_TEMP
      done
  fi
done

`cat $OUTPUT_TEMP | awk -F "/" '{print $NF;}' | sort | uniq > $OUTPUT`
`rm $OUTPUT_TEMP`

Symfony2 en vidéo

2011-01-03T00:00:00+01:00

Voici l’évolution du code source de symfony2 réalisé grâce à gource, ffmpef, pitivi et ubuntu ;)

(Il est possible de voir la vidéo en HD)

La ligne de commande qui a permit le résultat:

gource --title "Symfony2" -s .25 --file-idle-time 600  --auto-skip-seconds 1 -1920x1080 --output-framerate 30 --stop-at-end --max-files 1000000 --bloom- multiplier 1.1 --bloom-intensity .25 --background 101010  --highlight-dirs --highlight-users --hide filenames,date,progress --output-ppm-stream - | nice -n19 ffmpeg -y -b 3000k -r 30 -f image2pipe -vcodec ppm -i - -vcodec libx264 -vpre hq -crf 22 -threads 0 symfony.avi

Comment utiliser le Routeur du Zend Framework

2010-08-09T00:00:00+02:00

Je suppose que vous connaissez déjà tous l’url rewriting. Il est assez simple de mettre en place des formats d’URL (user firendly) prédéfinis avec Zend. On va voir ensemble comment faire.

Comme souvent avec le Zend Framework, il y a plusieurs façons de faire. Je vais vous en montrer deux. Une première en PHP, puis une deuxième avec le fichier de configuration application.ini. Quelque que soit la méthode, tout le code PHP sera à mettre dans le fichier bootstrap.php. Pourquoi ? Car il faut bien que le routage s’effectue avant le premier dispatch.

Préparation du bootstrap

On peut commencer par préparer notre bootstrap : il faut ajouter une nouvelle méthode :

protected function _initRouter() {
    $front = $this->bootstrap('FrontController')->getResource('FrontController');
    $router = $front->getRouter();
}

On ajoute la méthode _initRouter(). Pour l’instant cette méthode est un peu vide. La première ligne de code sert à démarrer le bootstrapsi cela n’avait pas encore été fait puis a récupérer le FrontController depuis le registre du bootstrap. La deuxième ligne sert à récupérer le router.

Configuration en php depuis le bootstrap

Syntaxe d’ajout

Il existe différent type de route possible. Des routes statiques, dynamiques, basés sur des expressions régulières, basés sur le domaine et sous-domaines … Mais quelque soit le type de route choisi, la syntaxe reste la même. Il faut commencer par créer une route, puis ensuite l’ajouter au routeur.

$uneRoute = new Zend_Controller_Router_Route($route, $defaults, $reqs);
$router->addRoute('uneRoute', $uneRoute);

$route correspond a l’Uri de la ressource. C’est le bout de l’URL qui se trouve après le nom de domaine. Par exemple l’Uri peut être ‘a-propos’ ou alors ‘contactez-nous’.
$default doit être un tableau contenant les informations de redirection (module, controller, action, …)
$reqs est optionnels, il permet d’ajouter des contraintes.
$uneRoute est la route au format Zend_Controller_Router_Route

enfin la pseudo-constante uneRoute est la clé identifiant la route. En effet il est possible de retrouver une route enregistrée dans le routeur grâce et uniquement grâce à cette clé.

Note : il est très fortement déconseillé de mettre des accents ou des caractères « bizarres » dans le nom de la route ou dans la clé de la route.

Routage Statique

On va commencer avec le routage statique. Avec le routage statique, il n’est pas vraiment possible de transmettre des variables en GET. On utilise par exemple le routage statique pour la page a-propos, contact etc … Voici un exemple :

protected function _initRouter() {
    $front = $this->bootstrap('FrontController')->getResource('FrontController');
    $router = $front->getRouter();
    $route = new Zend_Controller_Router_Route('accueil', array('controller' => 'index', 'action' => 'index')));
    $router->addRoute('accueil', $route);
}

Note : Ici j’ai remis tous le code à mettre dans le bootstrap. Dans la suite du tutoriel, je ne mettrais que les lignes de code intéressantes (i.e. les deux dernières lignes).

Dans cette exemple, le fait de se rendre sur la page http://exemple.com/accueil aura le même effet que d’aller sur la page http://exemple.com/index/index. Bien entendu, ce n’est pas une redirection (l’url ne change pas), mais bien un vrai routage ou ré-écriture d’Url. Dans cet exemple, la route ‘accueil’ porte le même nom que la clé. C’est en général plus simple de mettre les même valeurs, ou alors des valeurs proches.

Routage Dynamique

Qu’est-ce que le routage dynamique ? Par exemple vous voulez qu’une partie de l’url soit dynamique : un id, un nom de fonction, un message … Il faut donc, dans le routeur, nommé cette variable. Pour ce faire il faut utiliser les « : » devant le nom de votre variable. Voici un exemple ou l’on veut faire passer une message en paramètre (GET) de notre URL :

$route = new Zend_Controller_Router_Route('contact/:topic', array('controller' => 'index', 'action' => 'contact','topic' => 'Topic par defaut'));
$router->addRoute('contact', $route);

Ici nous faisons passer dans les paramètres GET un sujet (topic). Ainsi si l’on se rend à l’adresse suivante : http://exemple.com/contact/Mon Topic, le controller exécuter sera le controller indexController, et l’action exécuter sera l’action contactAction. On pourra récupérer la valeur de topicgrâce à :

$this->getRequest()->getParam('topic');

Il faut placer ce code dans la méthode contactAction du fichier indexController.php. C’est transparent pour l’utilisateur, mais il y a bien eu une ré-écriture d’url. Sans celle ci l’URL aurai pu être : http://exemple.com/contact/?topic=Mon Topic.

On peut aussi attribuer une valeur par défaut à notre variable topic. C’est un des arguments du tableau $default : topic => Topic par defaut. Donc si l’utilisateur se rend à cette adresse : http://exemple.com/contact la valeur de topic sera : Topic par defaut.

Vous pouvez aussi remarquer qu’ici la route est différente de la clé de celle-ci (contact/:topic VS contact).

Routage Dynamique avec des contraintes

On peut ajouter des contraintes aux routages dynamique. Comme par exemple forcer que la variable x ou y soit un entier ou un string. On utilise pour ca la variable $reqs :

$route = new Zend_Controller_Router_Route(
    'membres/:id/`',
    array(
        'controller' => 'index', 'action' => 'membres'
    ),
    array('id' => 'd+')
);
$router->addRoute('membres', $route);

Ici on force la route à utiliser un id de type nombre. Si ce n’est pas un nombre, l’URL ne passera pas dans la route, et il y aura une erreur.

Vous pouvez remarquer aussi qu’il est possible d’utiliser des caractères joker (wildcard). Le caractère ` symbolise tout type de caractère. Grâce a ce caractère, il est possible de mettre a peu près tout ce que l’on veut dans l’url. Il est donc possible de faire passer des informations dans l’URL même avec un routages statiques.

Routage avec les expressions régulières.

On à déjà vu le routage statique et le routage dynamique. Mais juste avec ces deux routages, il n’est pas encore possible de réaliser toutes les routes inimaginables. Par exemple, il n’est pas encore possible de faire une route qui ressemblerai a ca : http://exemple.com/team/25-aka ou alors http://exemple.com/blogpost/9-Comment-faire-cuire-une-pizza.html.

Voila le code d’une route :

$routeRegex = new Zend_Controller_Router_Route_Regex(
    'teams/(d+)-(w+)',
    array('controller' =>'index', 'action' => 'teams'),
    array(1 => 'id',2=>'name'),
    'teams/%d-%s'
);
$router->addRoute('teams', $routeRegex);

Il faut noter que la route n’est plus de type Zend_Controller_Router_Route mais de type Zend_Controller_Router_Route_Regex.

La route en elle-même est à peu près la même que pour le routage dynamique. Il
faut utiliser des expressions régulières. Ici les routes acceptées sont du type: http://exemple.com/teams/NOMBRE-STRING.

Le troisième argument du constructeur est un peu différent. Il permet de mapper (i.e. binder, associé) les ‘variables’ capturées par la regxp (grâce aux parenthèse) à des noms de variables. Par exemple, ici le nombre capturé sera mapper à la variable id et le string sera mappé à la variable name.

Enfin le dernier paramètre du constructeur sert au reverse. Il est possible (comme pour tous les autres types de route) d’utiliser un ViewHelper pour construire notre url (dans le cas où l’on veut faire un lien par exemple). Cependant avec une expression régulière en entré, il n’est pas très facile de pouvoir deviner le pattern en sortie. C’est pourquoi il y a ce dernier argument qui est facultatif. En effet il est facultatif, car tant qu’on n’utilise pas le ViewHelper, on n »en a pas besoin.

Note : on verre plus tard comment utiliser le ViewHelper url() avec les routes.

Configuration avec un fichier de configuration .ini

Note : pour cette partie, je ne vais pas trop détaillé le code. Il reste assez similaire pour le bootstrap. Le fichier .ini reprend le même fonctionnement qu’en php.

Configuration du Bootstrap

Il faut commencer par créet une nouvelle méthode dans le fichier bootstrap.php

protected function _initRouter() {

$front = $this->bootstrap('FrontController')->getResource('FrontController');
$router = $front->getRouter();
$config = new Zend_Config_Ini(APPLICATION_PATH . '/configs/application.ini', 'production');
$routing = new Zend_Controller_Router_Rewrite();
$routing->addConfig($config, 'routes');
 $front->setRouter($routing);}

Application.ini

Et maintenant, il faut coller ce code dans le fichier application.ini, dans la section production

; Routage

routes.accueil.route = "accueil"
routes.accueil.defaults.controller = "index"
routes.accueil.defaults.action = "index"

routes.apropos.type = "Zend_Controller_Router_Route"
routes.apropos.route = "a-propos"
routes.apropos.defaults.controller = "index"
routes.apropos.defaults.action = "apropos"

routes.contact.type = "Zend_Controller_Router_Route"
routes.contact.route = "contact/:topic"
routes.contact.defaults.controller = "index"
routes.contact.defaults.action = "contact"
routes.contact.defaults.topic = "Topic par defaut"

routes.membres.type = "Zend_Controller_Router_Route"
routes.membres.route = "membres/:id/`"
routes.membres.defaults.controller = "index"
routes.membres.defaults.action = "membres"
routes.membres.reqs.id = "d+"

routes.teams.type = "Zend_Controller_Router_Route_Regex"
routes.teams.route = "teams/(d+)-(w+)"
routes.teams.defaults.controller = "index"
routes.teams.defaults.action = "teams"
routes.teams.map.1 = "id"
routes.teams.map.2 = "name"
routes.teams.reverse ="teams/%d-%s"

On peut voir que pour un routage statique simple, 3 lignes suffisent (cf accueil). Cependant on peur forcer le type de la route (cf apropos).

Comme en PHP, il est aussi possible de définir une route dynamique (cf contact). Et on peut aussi faire une validation par expressions régulières (cf membres).

Enfin pour utiliser un route de type expression régulière, il faut utilise le type « Zend_Controller_Router_Route_Regex » (cf teams).

Utilisation de l’aide de Vue url()

L’aide de vue url() est très utile. Il est possible de l’utiliser avec le système de route du Framework. On peut l’utiliser depuis une vue ou depuis le layout. En accord avec la définition des routes vu précédemment, on peut l’appeler de la façon suivante :

echo $this->url(array(),'accueil').'<br />';
echo $this->url(array(),'apropos').'<br />';
echo $this->url(array('topic'=>'Sujet du message'),'contact').'<br />';
echo $this->url(array('id'=>'78'),'membres').'<br />';
echo $this->url(array('id'=>'25','name'=>'aka'),'teams').'<br />';

Le première argument doit etre un tableau (array). Il représente les arguments (ou paramètres) de la route. C’est un tableau associatif. La clé représente le nom de la variable, et la valeur représente la valeur de cette variable. Le deuxième argument représente la nom de la route.

ZFDebug : Un plugin pour Zend Framework

2010-08-05T00:00:00+02:00

ZFDebug est un outils très utile lorsqu’on développe avec Zend. En effet ce plugin, qui ne demande presque aucunes configurations, permet de mettre en évidence beaucoup d’informations utilises. On va voir commment l’installer dans un projet déjà existant (ou un nouveau, ca ne change rien).Donc ce plugin va ajouter automatiquement une barre d’outils en bas de votre page. Sur cette barre, on peut voire les informations suivantes :

Cache: Information sur Zend_Cache et APC.
Database: Liste complète des requêtes SQL ainsi que les temps d’exécution.
Exception: Capture des erreurs et exceptions.
File: Nombre et poids des fichiers inclus.
Html: Nombre de fichier JS et CSS inclus. Liens pour passer la page au validateur W3C.
Memory: Utilisation de la mémoire.
Registry: Contenu du Zend_Registry
Time: Information sur les temps d’exécution.
Variables: Variables de vues, de requêtes, de $COOKIE et $POST

Voila à quoi ressemble cette barre : (Note : Tous les modules ne sont pas chargé)

Alors pour l’installer il faut commencer par télécharger la dernière version sur le site du projet. Ensuite il faut extraire l’archive et déplacer le dossier ZFDebug qui se trouve dans le dossier library de l’archive dans votre dossier library de votre projet. Puis il faut configurer le bootstrap pour qu’il démarre le plugin. Il faut placer le code qui suit tout à la fin du bootstrap :

protected function _initZFDebug() {
    // Setup autoloader with namespace
    $autoloader = Zend_Loader_Autoloader::getInstance();
    $autoloader->registerNamespace('ZFDebug');

    // Ensure the front controller is initialized
    $this->bootstrap('FrontController');

    // Retrieve the front controller from the bootstrap registry
    $front = $this->getResource('FrontController');

    // Only enable zfdebug if options have been specified for it
    if ($this->hasOption('zfdebug')) {
        // Create ZFDebug instance
        $zfdebug = new
        ZFDebug_Controller_Plugin_Debug($this->getOption('zfdebug'));

        // Register ZFDebug with the front controller
        $front->registerPlugin($zfdebug);
    }
}

Et enfin, pour qu’il démarre, il faut ajouter la configuration de la barre dans le fichier application.ini et plus précisément dans la partie [development : production] pour que cette barre ne se retrouve que sur les machines de développement.

zfdebug.plugins.Variables = null
zfdebug.plugins.Time = null
zfdebug.plugins.Memory = null
zfdebug.plugins.Exception = null
zfdebug.plugins.Html = null
zfdebug.plugins.Registry = null
; zfdebug.plugins.File = null
; zfdebug.plugins.Cache = null
; zfdebug.plugins.Database = null

Voila le fichier de configuration « minimum ». Il est possible d’activer ou désactiver des fonctionnalités juste en commentant ou dé-commentant une ligne. Il y a plus d’information sur le wiki du plugin.

Et voila, la barre de Debug se retrouve automatiquement en bas de votre page. Si ce n’est pas le cas, pensez a vérifier que vous etes bien sur un environement de developpement. Si vous etes en production, il faudra ajouter la ligne suivante en haut du fichier index.php qui se trouve dans le répertoire public.

apache_setenv("APPLICATION_ENV", "development");

Qu'est-ce que PECL ?

2010-05-10T00:00:00+02:00

Il y a quelques semaines un rapport sur l’utilisation de PHP sur les serveurs debian est sorti (http://popcon.debian.org/ ; vraiment pas sexy ! ). Industrialisation PHP en a fait une bonne analyse, je vous conseil de la lire. En lisant ce rapport, j’ai été assez étonné sur les pourcentages d’utilisation des extensions PECL et PEAR. On va donc commencer par faire une petite piqure de rappel sur PECL.

PECL est l’anagramme de PHP Extension Community Library (on le prononce pickle). C’est une librairie d’extensions codées en C issu de la communauté PHP pour le PHP. Ces extensions viennent directement se greffer au moteur PHP (Liste des Extensions). Il y a par exemple des extensions pour le débogage, le cache, la sécurité, les gui … Ces extensions ont l’avantage d’être codées en C, donc elles sont beaucoup plus rapide et performantes que les librairies codées en PHP. Par contre il faut aussi savoir que plusieurs extensions ne sont plus maintenues, en effet, il arrive souvent que des extensions soient directement intégré directement au moteur PHP (comme domxml ou json) ou alors elles sont abandonnées :S.

Quelques exemples d’extentions connu :

memcache : offre la possibilité de mettre des objets en cache et donc de réduire la consommation CPU (et réduit l’utilisation de MySQL)
imagick : pour gérer les images. Offre plus d’options que GD2
XDebug : pour améliorer le débogage

Il y a plusieurs types d’utilisation de ces extensions. En fait soit l’extension rajoute des nouvelles fonctions à notre moteur php (comme avec imagick, exemple), soit l’extension redéfinit une fonction (on verra le cas dans un projet tuto avec var_dump).

Pour installer des extensions PECL, il y a plusieurs écoles.

Pour les utilisateurs de Windows, il y a souvent deux options :
- Télécharger les binaires et les copier au bon endroit, puis éditer le php.ini
- Télécharger le code source et re-compiler PHP (ou juste l'extension)
Pour les utilisateurs de Linux (et surement Mac…) :
- On peut aussi télécharger les sources a la main et compiler le tout (ou juste l'extension)
- Ou Une ligne de commande suffit :
```
pecl install <nom du paquet>
```

L’avantage d’être sous Linux, c’est que c’est plus simple et surtout plus à jour sachant que PECL fonctionne comme un dépôt, d’ailleurs c’est un dépôt (comme apt par exemple)

Documentation sur php.net

Architecture du Zend Framework 1.10 en MVC

2010-03-18T00:00:00+01:00

Depuis quelques versions du Zend Framework, l’architecture de celui-ci en mode MVC à un petit peu changé. Je vous donne le nouveau schémas, et je l’explique ensuite. La racine des dossiers est (chez moi) le dossier « zftuto ». Je précise que cette structure a été obtenu grâce aux Zend_Tool (cf prochain tutoriel).

Dans ce dossier nous avons :

application : c’est le dossier où tous notre code va se situer, il ne doit pas être accessible depuis l’extérieur.
- configs : c’est le dossier qui va contenir tous nos fichiers de configuration
  - application.ini : C’est le fichier qui permet de définir les réglage de l’application comme les paramètre de base de données, les chemins par défaut …
- controllers : c’est le dossier qui va contenir tous les controllers
- forms : c’est un nouveau dossier qui contient maintenant tous les formulaires
- layouts/scripts/ : c’est le dossier qui contient les fichiers de layout
  - layout.phtml : layout (ou template) de base de notre application
- models : c’est le dossier qui contient tous les modèles, ou plus exactement tous notre code métier
  - DbTable : c’est le dossier qui contient toutes les représentation de nos tables (ORM).
- Views : c’est le dossier qui contient tous ce qui touchent a l’affichage
  - helpers : c’est le dossier qui contient les aides de vues
  - scripts : c’est le dossier qui contient les dossiers contenant les vues
docs : c’est le dossier qui contient la documentation (oui il en faut)
library : c’est le dossier qui contient les librairies
zend : c’est dans ce dossier qu’il faut mettre la librairie du Zend Framework
public : c’est le seul dossier qui doit être accessible depuis l’extérieur.
- index.php : c’est le fichier qui va démarrer notre application
tests : c’est le dossier qui contient tous les fichiers pour faire des tests unitaires.

Application de site E-Commerce [Code-Source]

2010-03-18T00:00:00+01:00

Comme vous l’avez peut être vu passer sur twitter, j’ai du faire pour les cours une application e-commerce très basique. J’ai choisis de la faire avec Zend. Et du coup je partage le code ici ;). Cette application est très simplifié : il n’y a qu’une page produit, avec la possibilité d’ajouter des produits dans un panier et ensuite de gérer son panier. Il y a aussi la toute la partie gestion des utilisateurs : connexion, enregistrement, déconnexion etc… Et enfin il y a une page paiement qui vérifie les informations de la carte bancaire.

Quelques points techniques abordés dans cette application :

Bootstrap (Zend_Application)
Controller, View, Model (MVC)
Mapping de base de données (ORM) (Zend_Db_Table)
Formulaires, Validations, Décorateurs (Zend_Form, Zend_Validate)
Layout et Aides de vue (Zend_View_Helper)
Authentification (Zend_Auth)
Session (Zend_Session)
Cookie
Zend_Text_Figlet (Bonus ca :))

voila quelques screenshots :

Et enfin les sources à télécharger

Comment bien démarrer un projet Zend Framework grâce aux Zend_Tool

2010-03-18T00:00:00+01:00

Cet article est une mise à jour du tutoriel sur l’outil Zend_Tool. Donc depuis quelque temps dans le Zend Framework, il y a de nouvelles fonctionnalités. Mais pour bien faire les choses, on va reprendre Zend_Tool depuis le début.

Qu’est-ce que Zend_Tool ?

Zend Tool est un outils qui s’utilise en ligne de commande (depuis une console) et qui permet de mettre en place la structure de son projet, d’ajouter des controllers, actions, vues, modules… D’après la roadmap de Zend, cet outils à pour objectif de devenir très puissant.

Introduction

Alors il va falloir commencer par télécharger le Zend Framework. On l’extrait, chez moi c’est dans le répertoire : « /home/lyrix/prog/php/Lib/Zend_librairie/ZendFramework-1.10.2/ ». On va donc créer un alias pour nous faciliter la vie. Si vous avez la chance d’être sur un système linux (ou mac) une ligne de commande suffit :

alias zf="/home/lyrix/prog/php/Lib/Zend_librairie/ZendFramework-1.10.2/bin/zf.sh"

Vous pouvez aussi ajouter cette commande a votre fichier de configuration du bash (~/.bashrc), pour que l’alias soit toujours actif. On va ensuite aller dans le dossier où l’on veut que notre projet soit crée.

cd /home/lyrix/prog/php/2010/

On nommera ce projet « zftuto ». Création de projet avec Zend_Tool on commence par créer notre projet :

zf create project
./zftuto/ zftuto

./zftuto/ représente le PATH de la racine de l’application. zftuto représente le nom de l’application. Il faut maintenant se déplacer dans le dossier contenant l’application.

cd zftuto/

Base de donnée

Zend_Tool peut se connecter à une base de donnée, pour ensuite nous créer les classes métiers représentant les tables de notre bases de données (ORM). On commence par configurer notre application pour qu’elle se connecte à la BDD. Puis ensuite on génère nos classes :

zf configure db-adapter "adapter=pdo_mysql&username=ecommerce&password=ecommerce&dbname=ecommerce"
zf create db-table.fromdatabase

Le nom des variables est assez explicite pour que je ne les détail pas.

Layout

On peut maintenant activer la gestion d’un layout depuis zend tool.

zf enable layout

Formulaire

On peut créer un formulaire en ligne de commande :

zf create form UserCU

Model

Pour créer un nouveau model (ou classe métier) :

zf create model TestModel

Controller, Action, Vue :

Et bien sur on peut toujours ajouter un controller (avec la vue associé)

zf create controller Users
zf create action read Users
zf create view read2 Users

Module :

On peut aussi créer des modules :

zf create module Moduletest

Aide :

Pour de l’aide, vous pouvez directement depuis votre console exécuter la commande suivante :

zf ?

Conclusion

Si on fait attention, le nommage des classes a changé. Il y a maintenant un namespace « application ». Ce qui a mon goût est plus propre, et anticipe peut être les changements qu’il va y avoir avec php 5.3 puis php 6

Gerer l'authentification avec Zend_Auth du Zend Framework

2009-12-23T00:00:00+01:00

Comment faire un système de login sur son application ? On va voir comment mettre en place un système de connexion d’utilisateur dans son application avec le Zend Framework. Pour ce faire on va utiliser le composant Zend_Auth. Il va falloir commencer par faire le formulaire de login qui n’est pas très compliqué. Faire la validation de ce formulaire puis si il est valide s’occuper de la partie Zend_Auth ou authentification. Enfin nous verrons comment faire un petit Zend_View_Helper (aide de vue) pour créer automatiquement des liens (« login» ou « logout »)

Création du formulaire de login :

On va allé assez vite sur la création du formulaire dans la mesure ou j’explique dans un autre tutoriel comment faire un formulaire.

class Model_Form_User_Login extends Zend_Form {

public function init(){
    $this->setName('add_user');

    $email = new Model_Form_EText('email','Adresse Email : ');

    $password = new Zend_Form_Element_Password('password');
    $password->setLabel('Mot de pase : ')
        ->setRequired(true)
        ->addFilter('StripTags')
        ->addFilter('StringTrim');

    $submit = new Zend_Form_Element_Submit('submit');
    $submit->setAttrib('id', 'submitbutton')
        ->setLabel('Se connecter');

    $elements = array($email,$password, $submit);
    $this->addElements($elements);

    $this->setDecorators(array(
        'FormElements',
        array('HtmlTag', array('tag' => 'dl', 'class' => 'zend_form')),
        array('Errors', array('placement' => 'apend')),
        'Form'
    ));
}

}

On voit qu’on utilise un champ email et un champ password et bien sur un bouton valider. Si la classe de l’email vous parait bizarre je vous conseil de lire le tutoriel sur les formulaires. Enfin les dernières lignes concernent la mise en forme du formulaire ainsi que la position des messages d’erreurs qui seront envoyés (ajoutés) par le modèle pour la vérification du couple Email / Password.

Le controller

Le controller est dans la classe LoginController et l’action que nous allons utiliser est loginAction. On commence par donner une instance de notre formulaire à la vue pour qu’elle puisse l’afficher.

$form = new
Model_Form_User_Login();
$this->view->formLogin = $form;

Ensuite on vérifie qu’il y ai des données postées, on les récupère et on les valide.

if ($this->_request->isPost ()) {
    $formData = $this->_request->getPost ();
    if ($form->isValid ( $formData )) {
    }
}

Si elles sont valides, on récupère les données :

$email = $form->getValue ( 'email' );
$password = $form->getValue ( 'password' );

Enfin on arrive à la partie qui concerne Zend_Auth. Il faut commencer par créer ce qu’on appel un Zend_Auth_Adapter_DbTable, c’est un composant de Zend_Auth qui va pouvoir se connecter à la BDD. Cet nouvel objet va prendre en paramètre un Zend_Db_Adapter_Abstract, c’est à dire un connecteur à la base de donnée. Dans notre cas nous allons prendre le connecteur principal, celui qui est définit dans les paramètres globaux de Zend (application.ini)

$authAdapter = new Zend_Auth_Adapter_DbTable ( Zend_Db_Table::getDefaultAdapter () );

Enfin il faut donner quelques informations à cet adaptateur :

Le nom de la table qui contient les utilisateurs (ici users)
Le nom de la colonne qui contient les identifiants (ici email)
Le nom de la colonne qui contient les mots de passe (ici password)
Le type de hashage dans la base (ici MD5)
La valeur de l’email
La valeur du mot de passe

$authAdapter->setTableName ( 'users' )
    ->setIdentityColumn ( 'email' )
    ->setCredentialColumn ( 'password' )
    ->setCredentialTreatment ( 'MD5(?)' )
    ->setIdentity ( $email )
    ->setCredential ( $password );

Enfin on essaye d’identifier l’utilisateur :

$authAuthenticate = $authAdapter->authenticate ();

Maintenant il faut regarder si cette authentification à réussi ou échoué.

if ($authAuthenticate->isValid ()) {
}

Si elle est valide, on va mettre en variable de session les informations de l’utilisateur. À ce moment vous pouvez mettre toutes les informations relatives à l’utilisateur. On peu même envisager de créer une classe pour stocker toutes ces informations. Dans le cas présent, seule les informations issu de la table users sont utiles. On commence donc par récupérer l’espace de stockage (storage) par défaut de l’application

$storage = Zend_Auth::getInstance ()->getStorage ();

Puis on y ajoute les informations de l’utilisateur, on y enlève bien sur le mot de passe :

write ( $authAdapter->getResultRowObject ( null, 'password' ) );

Et enfin on redirige l’utilisateur sur la page principale de l’application

$this->_helper->redirector ( 'index', 'index' );

Et pour finir si le couple login / password n’était pas bon, on ajoute une description au formulaire :

} else {
    $form->addError ( 'Il n'existe pas d'utilisateur avec ce mot de passe' );
}

Voilà l’action du controller est faite on peu passer à la suite.

Déconnexion

Si l’utilisateur veut se déconnecter, il doit cliquer sur un lien qui map l’action suivante :

public function logoutAction() {
    Zend_Auth::getInstance()->clearIdentity ();
    $this->_helper->redirector ( 'index', 'index' );
}

Grâce à la ligne Zend_Auth::getInstance ()->clearIdentity (); on supprime l’identification de l’utilisateur.

Vérification de connexion

Il faut bien entendu vérifier (si l’on code proprement) si l’utilisateur est déjà connecté si il veut se déconnecter, et il faut aussi vérifier que l’utilisateur connecté puisse seulement se déconnecter dans ce controller. On va utiliser la méthode preDispatch du controller, cette méthode est systématiquement appelé à l’exécution d’une action du controller. Je vous donne le code et je l’explique après :

public function preDispatch() {
    if (Zend_Auth::getInstance ()->hasIdentity ()) {
        if ('logout' != $this->getRequest ()->getActionName ()) {
            $this->_helper->redirector ( 'index', 'index' );
        }
    } else {
        if ('logout' == $this->getRequest ()->getActionName ()) {
            $this->_helper->redirector ( 'index' );
        }
    }
}

On commence par vérifier si l’utilisateur est connecté, si il l’est et que l’action sur laquelle il veut aller est différente de ‘logout’ on le renvoi sur la page d’accueil du site. Sinon, si il n’est pas connecté et qu’il veut se déconnecter, on l’envoi sur l’action qui permet de se connecter.

Zend_View_Helper

Comment faire automatiquement un lien qui permet de se connecter si on ne l’est pas, ou alors de se deconnecter si on l’est ? Et bien on utilise ce qu’on appel un Zend_View_Helper, c’est un bout de code qui va être utilisable dans le layout.

class Zend_View_Helper_ProfileLink extends Zend_View_Helper_Abstract {
    public function profileLink() {
        $helperUrl = new Zend_View_Helper_Url ( );
        $auth = Zend_Auth::getInstance ();
        if ($auth->hasIdentity ()) {
            $username = $auth->getIdentity ()->prenom . ' ' . strtoupper ( substr ( $auth->getIdentity ()->nom, 0, 1 ) ) . '.';
            $logoutLink = $helperUrl->url ( array ('action' => 'logout', 'controller' => 'login' ) );

            return 'Salut ' . $username . ' (<a href="' . $logoutLink . '">Logout</a>)';
        }
        $loginLink = $helperUrl->url ( array ('action' => 'login', 'controller' => 'login' ) );

        return '<a href="' . $loginLink . '">Login</a>';
    }
}

On commence par créer un nouveau Zend_View_Helper_Url pour nous aider à construire les URL, puis on récupère une instance de Zend_Auth. Donc si il y a un utilisateur de connecté, on récupère son identité. Puis on construit l’URL de déconnexion, et enfin on retourne la chaine de caractère (message + lien). Si l’utilisateur n’est pas connecté, on construit le lien de connexion, et on retourne la chaine de caractère. Si on veut utiliser ce script dans la vue, il va falloir faire :

echo $this->profileLink();

Et voila le code du controller en entier :

class LoginController extends Zend_Controller_Action {

    public function init() {
        /** Initialize action controller here */
        Zend_Auth::getInstance ()->clearIdentity ();

    }

    public function preDispatch() {
        if (Zend_Auth::getInstance ()->hasIdentity ()) {
            if ('logout' != $this->getRequest ()->getActionName ()) {
                $this->_helper->redirector ( 'index','index' );
            }
        } else {
            if ('logout' == $this->getRequest()->getActionName ()) {
                $this->_helper->redirector ( 'index' );
            }
        }
    }

    public function indexAction() {
        $this->_forward ( 'login' );
    }

    public function loginAction() {

        $form = new Model_Form_User_Login ( );
        $this->view->formLogin = $form;

        if ($this->_request->isPost ()) {
            $formData = $this->_request->getPost ();
            if ($form->isValid ( $formData )) {
                $email = $form->getValue ( 'email' );
                $password = $form->getValue ( 'password' );
                $authAdapter = new Zend_Auth_Adapter_DbTable ( Zend_Db_Table::getDefaultAdapter () );
                $authAdapter->setTableName ( 'users' )
                    ->setIdentityColumn ( 'email' )
                    ->setCredentialColumn ( 'password' )
                    ->setCredentialTreatment ( 'MD5(?)' )
                    ->setIdentity ( $email )
                    ->setCredential ( $password );
                $authAuthenticate = $authAdapter->authenticate ();
                if ($authAuthenticate->isValid ()) {
                    $storage = Zend_Auth::getInstance ()->getStorage ();
                    $storage->write ( $authAdapter->getResultRowObject ( null, 'password' ) );
                    $this->_helper->redirector ( 'index', 'index' );
                } else {
                    $form->addError ( 'Il n'existe pas d'utilisateur avec ce mot de passe' );
                }
            }
        }
        $this->render ( 'index' );
    }

    public function logoutAction() {
        Zend_Auth::getInstance ()->clearIdentity ();
        $this->_helper->redirector ( 'index', 'index' );
    }

}

Zend Framework, Formulaire et Base de donnée, partie 2

2009-11-20T00:00:00+01:00

On continue avec la deuxième partie de la gestion d’un formulaire, de la création de formulaire, et d’ajout de donnée en BDD dans le Zend Framework. Dans cette partie nous verrons comment afficher les données, les modifier à l’aide du même formulaire que pour l’ajout, et la suppression des données.

Sommaire

Afficher les données de la base de données.

Il faut tout d’abord toucher a notre controller qui gère la page user pour donner à la vue une instance de la classe >Model_DbTable_Users(). Vu que j’utilise souvent cette classe, j’ai fait une méthode dans la classe controller : (application/modules/Frontend/controllers/UserController.php)

private function getUsersAll() {
    $dbUser = new Model_DbTable_Users();
    return $dbUser->fetchAll()->toArray();
}

Et maintenant on a juste a passer cette classe à la vue :

public function indexAction(){
    $this->view->usersAll = $this->getUsersAll();
}

On passe maintenant à la vue (application/modules/Frontend/views/scripts/user/index.phtml).

if (isset($this->usersAll)): ?>
    <h2>
        <?php echo $this->translate('view_user_modify')?>:
    </h2>
    <table>
        <tr>
        <th><?php echo $this->translate('view_user_firstname')?></th>
        <th><?php echo $this->translate('view_user_name')?></th>
        <th><?php echo $this->translate('view_user_email')?></th>
        <th><?php echo $this->translate('view_user_modify')?></th>

        </tr>
        <?php foreach ($this->usersAll as $user){
            if ($user['active'] == 1){
                echo '<tr>';
            }else{
                echo '<tr style="text-decoration:line-through">';
            }
            echo '<td>'.$user['nom'].'</td>';
            echo '<td>'.$user['prenom'].'</td>';
            echo '<td>'.$user['email'].'</td>';

            echo '<td><a
            href="'.$this->url(array('action'=>'edit','id'=>$user['idUser'])).'">Modifier</a>
            | <a
            href="'.$this->url(array('action'=>'del','id'=>$user['idUser'])).'"
            >Supprimer</a></td>';
            echo '</tr>';
        }
        ?>
    </table>
<?php endif; ?>

On commence par vérifier que la variable usersAll est bien définit. Dans ce cas la on construit notre tableau assez naturellement. Encore une fois j’utilise ici la traduction du framework (mais on n’est pas forcé de le faire).

if ($user['active'] == 1) {
    echo '<tr>';
} else {
    echo '<tr style="text-decoration:line-through">';
}

Ce code sert juste a vérifié que l’utilisateur est actif. Si il ne l’est pas on barre la ligne :

<a href="<?php echo $this->url(array('action'=>'edit','id'=>$user['idUser'])) ?>">
    Modifier
</a>
|
<a href="<?php echo $this->url(array('action'=>'del','id'=>$user['idUser'])) ?>">
    Supprimer
</a>

Enfin cette ligne est assez sympa : en effet on veut pouvoir éditer et supprimer des utilisateurs. Il nous faut donc des liens pour le faire. Et bien pour fabriquer ces liens on va utiliser une aide de vues (View Helper : Zend_View_Helper_Url) qui va nous construire notre lien directement. On lui passe comme argument un tableau, avec comme clés l'action, le controller, le module et des paramètres. Tout ces champs ne sont pas obligatoires. Dans mon cas, je reste sur le même controller, et donc le même module. Donc je n’utilise que l’action et un paramètre id. Ce paramètre est passé en GET donc directement dans l’url. De plus zend va gérer automatiquement l’url rewriting, qui est beaucoup plus user-friendly et seo-friendly. Voyons ce que donne le résultat : (il y a un peu de css)

Modification d’un enregistrement

Donc notre lien pour modifier un utilisateur est déjà fait, et comme on a pu le voir, il pointe sur l’action edit du controller UserController.php. Il va donc falloir modifier celui-ci, ainsi que la classe qui gère le formulaire et la vue. On commence avec le formulaire. En fait on va utiliser la même classe que pour l’ajout, mais on va y rajouter un peu de code (à la fin de la méthode).

Model

$idUser = $this->getIdUser();
if (isset ( $idUser ) && $idUser != "") {
    $user = new Model_DbTable_Users ( );
    $user = $user->fetchRow ( array ("idUser = ?" => $idUser ) );
    if ($user != null) {
        $user = $user->toArray ();
        $this->populate ( $user );
    } else {
        throw new Zend_Exception ( "Il n'y a pas de
        d'utilisateur avec l'id : " . $idUser );
    }
    $password->setDescription ( "form_user_update_password_change" );
    $password->setRequired ( false );
    $submit->setLabel ( 'form_user_update_submit' );
}

On commence par récupérer la valeur de l’id de l’utilisateur. Bien entendu, il faut déclarer une variable (private) et faire le getter et le setter qui va bien. Si il y a bien une valeur et qu’elle est différente de null on récupère une instance de la classe Model_DbTable_Users. On sélectionne la ligne qui va bien en fonction de l’id. Si on a bien récupérer un utilisateur (c’est a dire qu’il y a bien un enregistrement avec cet id)> on peuple le formulaire, c’est a dire qu’on le rempli des données récupérer. Sinon on renvoi une erreur. Ensuite, ce n’est pas obligatoire, mais je laisse le choix a l’utilisateur : si il ne veut pas changer de mot de passe, il ne fait rien, sinon il en rentre un nouveau. Enfin on change le label du bouton envoyer>. Mais ce n’est pas finit. En effet il reste un problème de validateur> sur le champs email. Il vaut donc le supprimer, mais que si c’est le même email (saisi) que l’email qui est déjà dans la BDD. De la même marnière que dans la partie 1, on va devoir redéfinir la méthode isValid :

public function isValid($data)
{
    $this->getElement('password')->addValidator(new App_Validate_PasswordMatch($data['password2']));
    if ($this->getElement('email')->getValue() == $data['email']){
        $this->getElement('email')->removeValidator ( "Zend_Validate_Db_NoRecordExists" );
    }
    return parent::isValid($data);
}

Par rapport au code de la partie 1, on a rajouté le bloc IF : Si la valeur en base est la même que la valeur saisi, on supprime le validateur>, sinon on ne fait rien (et donc on le laisse). Voilà notre formulaire est enfin prêt. On passe maintenant au controller.

Controller

public function editAction() {
    try {
        $form = new Model_Form_User_User ( );
        $form->setIdUser($this->getRequest ()->getParam ( 'id' ));
        $form->init();
        $this->view->formUserEdit = $form;
    } catch (Zend_Exception $e) {
        $this->view->formUserEdit = $e->getMessage();
    }
}

On essaye d’instancier la classe Model_Form_User_User ( ). Ensuite on récupère la valeur du paramètre id (passer en GET) et on la passe a notre classe forme. On est obligé de refaire le formulaire puis on la passe a la vue. Si il y a un problème (pas d’utilisateur avec id X) on passe les erreurs a la vue.

if ($this->_request->isPost ()) {
    $formData = $this->_request->getPost ();
    if ($form->isValid ( $formData )) {
    }
}

Ensuite, comme dans la première partie, on vérifie qu’il y ai des données de poster, et les recupère puis on les passes au validateur.

$user = new Model_DbTable_Users ( );
if ($formData ['password'] == "") {
    unset ( $formData ['password'] );
    unset ( $formData ['password2'] );
} else {
    $formData ['password'] = md5 (
    $formData ['password'] );
    unset ( $formData ['password2'] );
}
unset ( $formData ['submit'] );
$result = $user->update ( $formData, array ("idUser = ?" => $formData ['idUser'] ) );

Si elle sont valide, on instancie la classe Model_DbTable_Users. On vérifie la valeur du champs password : Si elle est nul, on enlève du tableau de donnée formData les champs password et password2, sinon on chiffre en md5 le champ password et en enlève password2. Enfin on enlève le champ submit. Et pour finir on met a jour la base de donnée.

$this->_helper->redirector ( 'index', 'user' );

Enfin on redirige vers l’action index du controller user.

Vue

Ici c’est le même principe que pour le formulaire d’ajout

<?php if (isset($this->formUserEdit)) : ?>
    <h2>
        <?php echo $this->translate('view_user_edit')?>:
    </h2>
    <?php echo $this->formUserEdit; ?>
<?php endif ?>

Supprimer un Enregistrement

La suppression d’un utilisateur va se faire en deux étape, la première servant à confirmer la demande de suppression. Donc on crée une action intermédiaire qui passe à la vue la valeur de l’id de l’utilisateur.

public function delAction() {
    $id = $this->getRequest ()->getParam ( 'id' );
    $this->view->delUserId = $id;
    $this->render('index');
}

Et on ajoute à la vue le code qui va générer notre demande de suppression. Encore ici on réutilise l’aide de vue url.

<?php if (isset($this->delUserId)): ?>
    <h2>
        <?php echo $this->translate('are_you_sure')?>:
    </h2>
    <a
        href="<?php echo $this->url(array('action'=>'delete','id'=>$this->delUserId));?>">
        <?php echo $this->translate('yes')?>
    </a>
    <a href="<?php echo $this->url(array('action'=>'index','controller'=>'user'),null,true)?>">
        <?php echo $this->translate('no')?>
    </a>
<?php endif ?>

Enfin si l’utilisateur clique sur oui, on exécute l’action suivante :

public function deleteAction() {
    public function deleteAction() {
    $id = $this->getRequest ()->getParam ( 'id' );
    $user = new Model_DbTable_Users ( );
    $result = $user->delete ( array ("idUser = ?" => $id ) );
    $this->_helper->redirector ( 'index', 'user' );
}

Et voilà le tour est joué. On a bien supprimer notre utilisateur.

Conclusion

On à enfin finit la gestion d’une table de la base de donnée grâce a un seul formulaire. Je vous donne donc maintenant le code de tous les fichiers dont j’ai eu besoin. Il y a des petites différence dans la mesure ou j’ai ajouté des messages de confirmation ou d’échec. De plus la structure de l’archive n’est pas bonne du tout… Il y a bien tous les fichiers (enfin je pense, mais c’est plus a titre indicatif). Il ne fonctionneront pas sans le bootstrap, le fichier de config, le fichier de traduction et enfin la bdd. Je referais un gros package plus tard. Fichiers

Zend Framework, Formulaire et Base de donnée, partie 1

2009-11-19T00:00:00+01:00

Hello, On va voir aujourd’hui comment construire et gérer un formulaire, ajouter les données récupéré dans une base de données, afficher ces données, et enfin modifier et supprimer celles-ci. En gros, on va utiliser les propriétés CRUD de Zend Framework en y associant une base de donnée et un formulaire. P.S. : Pendant la rédaction de ce tuto, je me suis rendu compte qu’il allait être beaucoup trop gros, du coup j’ai décidé de le couper en deux parties, une première sur la création du formulaire et l’ajout en base, une deuxième sur la l’affichage, la modification et la suppression.

Sommaire

Préparation de la base de donnée :

CREATE TABLE IF NOT
EXISTS `Budget`.`users` (
*idUser` INT NOT NULL AUTO_INCREMENT ,
*nom` VARCHAR(20) NULL ,
*prenom` VARCHAR(20) NULL ,
*email` VARCHAR(30) NULL ,
*active` INT NULL ,
*level` INT NULL ,
*password` BIGINT NOT NULL ,
PRIMARY KEY (`idUser`) )
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
PACK_KEYS = DEFAULT

Comme on a vu dans un précédant tutoriel, il faut créer une classe qui va nous mapper les informations de la table (ORM du Zend Framework).

class Model_DbTable_Users extends Zend_Db_Table_Abstract {
    protected $_name = 'users';
    protected $_primary = array('idUser');
}

Préparation du formulaire

Il existe plusieurs façons de faire un formulaire : soit en utilisant des tableaux php, des objets php, un fichier xml etc… Pour ma part j’utilise des objets php et j’implémente pour chaque formulaire la classe Zend_Form (je vais y revenir). Pour plus de clarté dans mon arborescence de fichiers, je place tous mes formulaires, dans le dossier : application/models/Form/ et comme ce formulaire ci concerne l’ajout et/ou la modification d’un utilisateur, mon fichier User.php est dans le dossier : application/models/Form/User. Donc le fichier de base doit ressembler à ça :

class Model_Form_User_User extends Zend_Form {
    public function init() {
    }
}

Comme on peut le voir, il faut étendre la classe Zend_Form, et mettre tout notre code qui ajoute des éléments dans la méthode init(). Ce code sera directement exécuter lors de la création d’un nouveau formulaire. Mais on va très vite ajouter des éléments à notre formulaire, sinon il ne va pas servir à grand chose. On peut, par exemple, ajouter un champ input texte grâce a ce code (le principe reste le même pour tous les types d’éléments) :

$champText = new Zend_Form_Element_Text('champText');
$champText->setLabel('un champ texte')
    ->setRequired(true)
    ->addValidator('notEmpty')
    ->addFilter('StripTags')
    ->addFilter('StringTrim');

On commence par créer un nouvel élément de type input texte, puis on ajoute un label, on ajoute ensuite un validateur qui (dans ce cas) oblige la valeur à être rempli, puis on ajoute deux filtres. Il existe un grand nombre de validateurs et de filtres. On en verra quelques un ici. Mais comme on peut se douter, on va très souvent répéter le même code. Donc on peut se créer une petite classe qui ne va servir qu’a ajouter un champ de type input texte : (application/models/Form/EText.php)

class Model_Form_EText extends Zend_Form_Element_Text {

    public function __construct($options = null,$label) {
        parent::__construct($options);
        $this->setLabel($label)
            ->setRequired(true)
            ->addFilter('StripTags')
            ->addFilter('StringTrim');
    }
}

Voilà, je vous donne maintenant une partie du code du formulaire et j’explique les points nouveaux.

class Model_Form_User_User extends Zend_Form {

    public function init() {
        $this->setName ( 'add_user' );

        $id = new Zend_Form_Element_Hidden ( 'idUser' );

        $nom = new Model_Form_EText ( 'nom', 'form_user_add_name' );

        $prenom = new Model_Form_EText ( 'prenom', 'form_user_add_firstname' );

        $email = new Model_Form_EText ( 'email', 'form_user_add_mail' );
        $email->addValidator ( 'EmailAddress' )->addValidator( new Zend_Validate_Db_NoRecordExists ('users', 'email' ) );

        $password = new Zend_Form_Element_Password ( 'password' );
        $password->setLabel ( 'form_user_add_password' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' )->setRequired ( true );

        $password2 = new Zend_Form_Element_Password ( 'password2' );
        $password2->setLabel ( 'form_user_add_password2' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' );

        $active = new Zend_Form_Element_Checkbox ( 'active' );
        $active->setLabel ( 'form_user_add_enable' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' )->setValue ( 1 );

        $level = new Zend_Form_Element_Select ( 'level' );
        $level->setLabel ( 'form_user_add_level' )->addFilter ( 'StripTags' )->addFilter ( 'StringTrim' );

        $levelOptions = array ();
        for($i = 0; $i <= 9; $i ++) {
            $levelOptions [$i] = array ('key' => $i, 'value' => $i );
        }
        $level->addMultiOptions ( $levelOptions );

        $submit = new Zend_Form_Element_Submit ( 'submit' );
        $submit->setAttrib ( 'id', 'submitbutton' )->setLabel ( 'form_user_add_submit' );

        $elements = array ($id, $nom, $prenom, $email, $password, $password2, $active, $level, $submit );
        $this->addElements ( $elements );
    }
}

Pour commencer je donne un nom a mon formulaire, ce qui peut être pratique pour le retrouver, en effet le nom du formulaire correspond a son id dans le code html et css. On peut aussi ajouter d’autre options, comme l’action du controller, mais dans notre cas, le formulaire et sa page de destination (l’action) sont les mêmes, donc on pas besoin de le définir. Ensuite, comme on peut le voir, on crée plusieurs éléments :

l’id qui est un élément de type hidden, qui nous servira lors des mises à jour d’un utilisateur.
nom, prenom qui sont des éléments de type Etext, les éléments qu’on a crée un peu plus haut.
email
- Le champ email est aussi un champs de type Etext,
- On a ajouter un validateur d’adresse mail, pratique, le boulot est déjà fait ! ->addValidator('EmailAddress')
- On ajoute un second validateur qui vérifie que l’adresse mail n’est pas déjà dans la base de donnée: *addValidator (new Zend_Validate_Db_NoRecordExists('users','email')). Le premier paramètre est lenom de la table`. Le second est l’attribut qui doit être unique.
password et password2 sont des champs de type password.
active sert a savoir si l’utilisateur est actif. C’est un élément de type Checkbox, avec comme valeurpar défaut 1 (case coché)
level sert a niveau d’administration du site. De type Select On ajoute dans un tableau des correspondances key => value qui représentent les *options du select`
submit qui est notre bouton envoyer.

Les **labels ne sont pas très significatifs ou user-friendly, c’est normale, j’utilise la traduction du zend framework**. Enfin il ne reste plus qu’a ajouter tous ces éléments dans le formulaire lui même et le tours est joué, on a notre formulaire. Je tiens a rappelé qu’il existe vraiment un grand nombre de façon de fabriquer un formulaire, d’ajouter des filtres, des validateurs. Il y a quelques exemples ici, mais je ne peux pas faire un exemple pour chaque cas. Je vous recommande donc d’aller faire un tour sur sur le doc du zf.

Affichage du formulaire

Je ne vais pas m’occuper ici de styler le formulaire. Juste de l’afficher comme il vient. Par défaut zf utilise ce qu’on appel des décorateurs, il est possible de les personnaliser, mais ce n’est pas le but ici. Vous pouvez aller faire un tours sur le site de dator pour avoir un exemple de ce qu’on peut faire (même si je ne suis pas fan de sa technique, mais elle reste valide à 100% … huhu). Pour les décorateurs, le code a ajouter / modifier doit se trouver dans la classe qui fabrique notre formulaire. Donc il va falloir éditer la vu qui affichera le formulaire. Chez moi c’est application/modules/Frontend/views/scripts/user/index.phtml car c’est le controller userController.php qui va être appelé ici. Voilà a quoi doit ressembler la vues au minimum :

<?php if (isset($this->formUser)) : ?>
    <h2>
        <?php echo $this->translate('view_user_add')?> ?
    </h2>
    <?php echo $this->formUser ?>
<?php endif ?>

On fait une simple vérification pour voir sur le formulaire a bien était envoyé par le controller à la vue et on l’affiche.

Le controller du formulaire

Bon on arrive la gestion du controller de notre formulaire. Je vous livre le code et je l’explique ensuite : (application/modules/Frontend/controllers/UserController.php)

class UserController extends Zend_Controller_Action
{
    public function indexAction(){
    $form = new Model_Form_User_User();
    $this->view->formUser = $form;
    if ($this->_request->isPost()) {
        $formData = $this->_request->getPost();
        if ($form->isValid($formData)) {
            $users = new Model_DbTable_Users();
            $row = $users->createRow();
            $row->nom = $form->getValue('nom');
            $row->prenom = $form->getValue('prenom');
            $row->email = $form->getValue('email');
            $row->password = md5($form->getValue('password'));
            $row->active = $form->getValue('active');
            $row->level = $form->getValue('level');
            $result = $row->save();
            //On gere le resultat et l'action qui s'en suit.
            $form->reset();
        }
    }
}

Petit apercu avant de continuer

$form = new
Model_Form_User_User();
$this>view->formUser = $form;

On commence par instancier la classe du formulaire et on le donne à la vue. A partir de ce moment on peut déjà tester si notre formulaire s’affiche bien. Bien entendu ça ne sert a rien de cliquer sur envoyer, ça ne fonctionnera pas ! Comme on a pu le voir plus haut, la page de destination du formulaire est elle même. Donc le controller est le même. C’est donc dans la même méthode du même controller qu’on teste en premier si notre formulaire est valide et qu’ensuite on traite le résultat.

if ($this->_request->isPost()) {
     $formData = $this->_request->getPost();
}

On commence avec le IF pour voir si il y a eu des données de type POST, POST étant le type d’envoi par défaut pour les formulaires. On peut bien entendu envoyer notre formulaire en GET en modifiant la classe user.php. Ensuite on récupère nos données.

if ($form->isValid($formData)) {
}

Ce point est très intéressant, car il va automatiquement voir si notre formulaire est valide. C’est a dire qu’il va exécuter chaque validateurs de nos élement composant le formulaire. Si il y a au moins une erreur la validation ne passera pas, mais zf va** automatiquement refaire notre formulaire en reprenant les valeurs insérer, et en ajouter un message ou il y a eu des erreurs** (par exemple « la valeur est requise »). Ici encore on peut personnaliser le message. Dans mon cas j’utilise encore une fois la traduction. Bon et si le formulaire est valide ?

$users = new Model_DbTable_Users();
$row = $users->createRow();
$row->nom = $form->getValue('nom');
$row->prenom = $form->getValue('prenom');
$row->email = $form->getValue('email');
$row->password = md5($form->getValue('password'));
$row->active = $form->getValue('active');
$row->level = $form->getValue('level');
$result = $row->save();

Comme on veut (à la base) que notre formulaire nous serve à ajouter des utilisateurs en base, et bien on reprend le même code que dans le tutoriel sur la gestion des BDD ; On instancie la classe Model_DbTable_Users, on crée un nouvelle ligne, on ajoute tous nos champs, et enfin on sauvegarde. Bien entendu, on peut mettre la ligne $row->save() dans un bloque try-catch, mais si on a bien fait notre boulot sur les validateurs, normalement, il n’y a pas besoin.

reset();

Enfin on remet a zéro notre formulaire, c’est a dire qu’on vide tout les champs. On peut par la suite ajouter un message (pour l’ergonomie) qui s’affichera expliquant que l’ajout s’est bien effectué. Ici c’est donc juste un passage de variable à la vue. Voilà notre formulaire fonctionne mais il y reste encore des choses a voir.

Double vérification du password ; Validation avec données.

Du fait qu’il faille vérifier que l’utilisateur a bien rentré deux fois le même password, on va avoir besoin d’au moins un des deux password. On va donc redéfinir la méthode isValid de la classe Model_Form_User_User qui étend Zend_Form je vous rappel. Cette classe, comme on a vu plus haut, est systématiquement appelé, et elle appel à son tour tous les validateurs de tous les éléments. On va utiliser pour vérifier que l’utilisateur a bien rentré deux fois le même password grâce une classe de validation réalisé par l’ami dator :

class App_Validate_PasswordMatch extends Zend_Validate_Abstract
{
    const PASSWORD_MISMATCH = 'passwordMismatch';
    protected $_compare;
    protected $_messageTemplates = array(
        self::PASSWORD_MISMATCH => "PASSWORD_MISMATCH"
    );
    public function __construct($compare){
        $this->_compare = $compare;
    }
    public function isValid($value){
        $this->_setValue((string) $value);
        if ($value !== $this->_compare) {
            $this->_error(self::PASSWORD_MISMATCH);
            return false;
        }
        return true;
    }
}

On peut la mettre en bas de la classe Model_Form_User_User, ça ne pose pas de problème. Du coup il ne nous reste plus qu’a l’utiliser :

public function isValid($data)
{
    $this->getElement('password')->addValidator(new
    App_Validate_PasswordMatch($data['password2']));
    if ($this->getElement('email')->getValue() == $data['email']){
        $this->getElement('email')->removeValidator ( "Zend_Validate_Db_NoRecordExists");
    }
    return parent::isValid($data);
}

On commence par récupérer l’élément password, auquel on ajoute notre validateur personnalisé en lui donnée comme paramètre le password2 rentré par l’utilisateur. Ensuite on appelle la méthode « classique ».

Conclusion

Et voilà, on a finit avec notre formulaire. On peut bien sur l’améliorer et surtout le rendre plus joli. Je vous redonnerai tous les fichiers nécessaires lors de la deuxième ;) et on peut continuer avec la 2eme partie : affichage, modification et suppression.

Comment gérer une base de donnée avec le Zend Framework

2009-10-19T00:00:00+02:00

Alors la on va aborder un chapitre très important. Les bases de données sont bien sur très importantes pour un site web ou un service web. On va voir ensemble comment ajouter, modifier, supprimer des enregistrements (ou tuples) dans un table, dans une base de donnée. On va donc utiliser la gestion CRUD du Zend Framework 1.9.

Sommaire

Sommaire
Connexion a la base de donnée
Schémas de la table
Préparation de la classe métier
Obtenir et récupérer des enregistrements
Ajouter des enregistrements
Modifier des enregistrements
Supprimer des enregistrement
Etendre la classe métier
Conclusion

Connexion a la base de donnée.

La connexion à la base de donnée principale se fait toute seule. Je m’explique, c’est le bootstrap qui va initialiser notre connexion à la base de donnée. En fait le bootstrap va charger le fichier de configuration de l’application et c’est dans ce fichier que l’on va définir les paramètres de connexion a la BDD. Il faut donc éditer le fichier application/configs/application.ini

; DATABASE
resources.db.adapter = "MYSQLI"
resources.db.params.host = "localhost"
resources.db.params.username = "budget"
resources.db.params.password = "budget"
resources.db.params.dbname = "budget"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Si on veut que notre connexion à la BDD soit géré automatiquement, le schémas (ci dessus) est très rigide. En effet zend va chercher automatiquement si dans le fichier de configuration il y a des constantes «ressources.db.** » de défini, et si oui il va essayé de se connecter à la base de donnée. Il est bien sur possible d’avoir plusieurs connexions à différente SGBD (mysql, orable, DB2 …). Si vous utiliser mysql, il suffit de copier / coller le schémas ci dessus, et de bien remplacer les lignes : host, username, passwordet dbname qui signifie respectivement : hôte, nom d’utilisateur, mot de passe, nom de la BDD. Sinon l’adpater est le driver à utiliser pour se connecter (mysql, orable, DB2… ; se référer a la doc) ; date_format est le format de la date ; et isDefaultTableAdapter est pour savoir si cette connexion est la principale.

Schémas de la table

On va utiliser un exemple pour bien mettre en place ce tuto. On va utiliser une table d’utilisateur. Voilà le schémas :

CREATE TABLE IF NOT
EXISTS `users` (
  id int(50) NOT NULL auto_increment,
  *name` varchar(50) NOT NULL,
  firstname varchar(50) NOT NULL,
  email varchar(255) NOT NULL,
  *password` varchar(255) NOT NULL,
  phonenumber varchar(20) NOT NULL,
  *enable` int(1) NOT NULL,
  *level` int(1) NOT NULL,
  PRIMARY KEY (id),
  UNIQUE KEY email (email)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

On a donc :

Un id en auto-increment
Un nom
Un prénom
Une adresse email
Un mot de passe
Un numéro de téléphone
Un booléen pour savoir si l’utilisateur est activé
Un entier pour avoir le niveau d’administration
Une clé primaire et un index sur l’id
Une clé unique et un index sur l’email

Préparation de la classe métier.

Zend commence à gérer de façon assez autonome et automatique les BDD. Il y a maintenant un gestionnaire CRUD (Create, Read, Update, Delete=> Ajouter, Lire, Mettre a jour, Supprimer des enregistrements). Pour se faire il faut créer une class php. On est assez libre pour le nom des class et pour leurs emplacements, mais je vous recommanderai d’être assez logique et rigoureux. En fait il va falloir faire une **class par table de votre base de donnée**. Pour ma part, je mets presque toujours un « s » a la fin du nom de mes tables, car elles contiennent plusieurs enregistrements. Par exemple la table users contient plusieurs utilisateurs. Il faut maintenant créer une class qui représente cette table. On peut organiser ses class comme on veut, mais en général sur le petits projets je mets toutes mes class dans le dossier application/models/DbTable/. De plus je nomme toujours ma class avec le même nom que la table. A quoi doit ressembler la class (Voir la convention de nommage des models) :

<?php
class Model_DbTable_Users extends Zend_Db_Table {
    protected $_name = 'users';
}

Pour le nom de la class, il faut se référer au model dans le Zend Framework. Il faut étendre la class Zend_Db_Table. Enfin il faut ajouter l’attribut protected $_name qui a pour valeur le nom de la table dans la base de donnée. Et voilà, le plus dur est fait. On a maintenant une class qui possède un bon nombre de méthode CRUD.

Obtenir et récupérer des enregistrements

Comment obtenir tous les tuples d’une table ? Si il n’y a pas de close particulières, c’est super simple , on exécute le petit bout de code suivant :

private function getUsersAll()
{
    $dbUser = new Model_DbTable_Users();
    return $dbUser->fetchAll()->toArray();
}

Donc on instancie un nouveau Model_DbTable_Users, et on lui demande la retourner tous les enregistrements grâce a la méthode fetchAll, et enfin on convertit le résultats en tableau. Voilà le tours est joué ! Comment obtenir que certains enregistrements ?

private function getUsersByName($name = '')
{
    $dbUser = new Model_DbTable_Users();
    return $dbUser->fetchAll()->toArray(array('name = ?'=>
    $name));
}

Voilà, la méthode fetchAll possède 4 arguments: $where, $order,$count,$offset qui représente respectivement la clause where, le clause order by , et la clause limit (combien d’enregistrement et à partir de l’enregistrement numéro n ). Pour une utilisation plus poussé, je vous recommande de lire la doc du Zend Framework.

Ajouter un enregistrement

Comment ajouter un enregistrement dans la base de donnée ? Comme dans l’exemple précédant, on va ajouter un nouvel utilisateur.

$users = new
Model_DbTable_Users();
$row = $users->createRow();
$row->name = 'Nom';
$row->firstname = 'Prenom';
$row->email = 'email';
$row->password = md5('password');
$row->phonenumber = '0102030405';
$row->enable = 1;
$row->level = 9;
$result = $row->save();

On commence par instanciée un nouveau Model_DbTable_Users. Ensuite on crée une ligne, puis on ajoute a cette ligne les différents attributs, et enfin on sauvegarde cette ligne en table. On peut aussi faire la même chose en donnant a la méthode createRow un tableau en argument. :

$users = new Model_DbTable_Users();
$datas = array(
    'name'=>'Nom',
    'firstname'=>'Prenom',
    'email'=>'email2',
    'password'=>md5('password'),
    'phonenumber'=>'0102030405',
    'enable'=>1,
    'level'=>9,
);
$row = $users->createRow($datas);
$row->save();

Enfin on peut faire beaucoup plus simple. Je ne connais pas bien la différence entre les deux méthodes (la précédente et la suivante), si quelqu’un peut m’éclairer, je suis preneur.

$users = new Model_DbTable_Users();
$datas = array(
    'name'=>'Nom',
    'firstname'=>'Prenom',
    'email'=>'email3',
    'password'=>md5('password'),
    'phonenumber'=>'0102030405',
    'enable'=>1,
    'level'=>9,
);
$row = $users->insert($datas);

Bon, c’est assez simple d’ajouter un enregistrement en table ? On va un peu plus loin. Comment protéger ses enregistrements en table grâce a une **transaction SQL :

$users = new Model_DbTable_Users();
$datas = array(
    'name'=>'Nom',
    'firstname'=>'Prenom',
    'email'=>'email3',
    'password'=>md5('password'),
    'phonenumber'=>'0102030405',
    'enable'=>1,
    'level'=>9,
);
$defaultAdaptateur = Zend_Db_Table::getDefaultAdapter();
$defaultAdaptateur->beginTransaction();
try {
    $defaultAdaptateur->insert('users', $datas);
    $defaultAdaptateur->commit();
} catch (Exception $e) {
    $defaultAdaptateur->rollBack();
    echo $e->getMessage();
}

On commence de la même façon que pour la dernière méthode. Ensuite on récupère l’adaptateur de la base de donnée principale puis on commence une transaction. Il faut ensuite en-capsuler notre ajout à la base dans un bloque try-catch. On essaye d’insérer notre enregistrement puis si ça fonctionne on commit. Si ça ne fonctionne pas on fait un rollbacket on affiche les messages. Bien sur il est possible de n’utiliser qu’un bloque try-catch.

Mettre a jour un enregistrement

La méthode ici est très similaire à l’ajout d’un enregistrement. On peut mettre a jour uniquement qu’une seule ligne ou tout un groupes de ligne. Dans cet exemple on remplace tous les enregistrements ou l’attribut name est « Nom » par « Nom2 ».

$users = new Model_DbTable_Users();
$datas = array('name'=>'Nom2');
$users->update($datas,array('name = ?'=>'Nom'));
$this->render('index');

Ici les $datas sont les données qu’on va mettre a jour. La méthode updatesva tout faire. Le premier arguments est le tableau de donnée, le second argument correspond aux conditions de la clause **where. Dans ce cas la on explicite que l’attribut name doit correspondre a Nom.

Supprimer un enregistrement

Cette dernier action est la plus simple, il suffit de bien formuler la clause **where.

$users = new Model_DbTable_Users();
$users->delete(array('name = ?'=>'Nom2'));

Ici on supprimer tous les utilisateurs qui ont pour valeur d’attribut name : Nom2.

Extension de la class métier

Bien entendu, on peut ajouter des méthodes particulières a notre class métier. Comme par exemple pour avoir le nombre d’enregistrement :

public function getUserCount()
{
    $sql = 'select count(1) cnt from users';
    $stmt = $this->_db->query($sql);
    $results = $stmt->fetchAll();
    if ((sizeof($results) > 0) && (isset($results[0]['cnt']))) {
        return $results[0]['cnt'];
    }
    throw new Exception("Erreur : impossible d'obtenir le nombre
    d'utilisateur");
}

Conclusion

On peut bien sur en-capsuler un update, une suppression dans un block try-catch et de plus on est pas obligé d’utiliser les transaction sql qui sont quand même plus lourde. On verra dans un prochain tuto comme utiliser les clés étrangères.

Comment mettre en place un systeme de traduction dans Zend Framework

2009-10-15T00:00:00+02:00

Avoir un site, c’est bien, mais c’est encore mieux si on peut le traduire facilement dans plusieurs langues. On va voir ensemble comment mettre en place un fichier de traduction **avec **Zend_Translate dans notre application. Il y a plusieurs moyens de gérer les traductions avec Zend Framework. Chacun a ses avantages et inconvénients. La je vais utiliser un simple fichier php qui va contenir un tableau (array)avec les traductions. L’avantage du tableau php : on peut facilement le mettre a jour, il est lisible par un humain. Par contre il a un inconvénient : Si l’application est énorme, on aura des problème de performance. A vous de bien choisir la gestion de la traduction.

Le fichier de traduction :

Il faut le placer dans le dossier : application/languages/. Pour le nom on va être créatif et l’appeler fr.php pour la traduction en français. Il ressemble a ça :

<?php
return array(
    'key_1'=>'Traduction 1',
    'key_2'=>'Traduction 2',
);

Donc quand on va utiliser la pseudo-variable key_1, l’application traduira automatiquement **key_1 en Traduction 1 (bien sur si on est en français dans l’application. Sinon j’ai dit pseudo-variable car on utilise key_1 d’une façon bien particulières. Tout dépend du contexte. On va y venir...

Le bootstrap

Il faut bien entendu « dire » à notre application qu’il faut qu’elle utilise les traductions et il faut aussi lui donner une langue par défaut. On peut même faire en sorte que l’application choisisse elle même la langue en fonction de la position géographique de l’utilisateur final, mais la j’y reviendrais dans un prochain tuto. Voilà, on ajoute ce code dans notre bootstrap :

/**
* Initialize Translation
*
* @return Zend_Translate
*/
public function _initTranslate()
{
    $translate = new Zend_Translate('array', APPLICATION_PATH . '/languages/fr.php', 'fr');

    return Zend_Registry::set('Zend_Translate', $translate);
}

voilà on peut maintenant utiliser notre fichier de traduction :

Dans un model :

Ici c’est (relativement extrêmement) simple. Par exemple si on veut mettre un label a un élément d’un formulaire (Zend_Element, Zend_Form), et bien sur le traduire il n’y a rien a faire, il suffit de donner a la méthode setLabel la clé de notre tableau qui est dans le fichier fr.php. Par exemple pour un champs password :

$password = new Zend_Form_Element_Password(‘password’);
$password->setLabel(‘form_user_add_password’);

Et dans notre fichier fr.php :

'form_user_add_password'=>'Mot de passe : ',

**Petit tips **: Si on a besoin de traduire des messages d'erreurs liés aux validateurs (Zend_Validate) d'éléments du formulaire il faut ajouter dans le fichier de traduction, le message original renvoyé par le validateur. On peu trouvé les messages originaux ici (merci guiton)

//Pour la validation : valeur requise
'Value is required and can't be empty'=>'la valeur est requise',
//Pour la validation : Le champs values est deja dans la BDD
'A record matching %value% was found'=>'Il y a déja '%value%' dans la BDD',

Comme on peut le voir sur le deuxième exemple, on peut récupérer le paramètre %value% directement dans le message traduit. C'est la valeur qui a été saisi par l'utilisateur.

Dans une vue (view) :

Si on a besoin d'une traduction dans une vue, la c'est un tout petit peu plus compliqué :

<?php echo $this->translate('view_user_add')?>

Et dans notre fichier fr.php :

'view_user_add'=>'Ajouter un utilisateur',

Voilà, c'est assez simple, si on veut la traduction de 'key_1' il suffit de faire

$this->translate('key_1')

Bon voilà on a fait le tours ! Enfin il me semble. Il y a des questions ou des remarques ?

Comment gérer la navigation de son site avec le Zend Framework

2009-10-08T00:00:00+02:00

Dans ce tuto on va voir comment mettre en place un système automatique de navigation dans le Zend Framework. C’est a dire que notre menu de navigation soit dynamique et flexible. On pourra par exemple avoir notre chemin de navigation ou fil de navigation. On va donc utiliser le composant Zend_Navigation. On a plusieurs possibilité pour la gestion et le stockage de l’arbre (ou graphe) de navigation. Moi j’ai choisit le XML pour le stockage, et la gestion par module, controller et action. Enfin on utilise aussi la traduction automatique ;)

Sommaire

Sommaire
Introduction
Bootstrap
Layout
Hiérarchie de pages
Classe css de la page en cours
Fil de Navigation ou breadcrumbs

Introduction

On commence par un aperçu de notre fichier de navigation :

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
<nav>
    <home>
        <label>nav_home</label>
        <controller>index</controller>
    </home>
</nav>
</configdata>

Petite explication : la balise configdata ne sert que de nœud racine, la balise nav sert a repérer notre section de la gestion de la navigation. Dans mon cas je n’utilise le fichier navigation.xml que pour gérer la navigation, pour on pourrait envisager de n’avoir qu’un seul gros fichier xml pour gérer toutes nos données et variables de l’application. Ensuite on a une balise home, elle représente un lien du menu, on lui donne le nom qu’on veut, elle va représenter dans notre cas la page d’accueil. Elle a pour classe fille une balise label qui définit le nom du lien. J’utilise nav_home car dans mon fichier de traduction j’ai une clé nav_home qui fait référence a home. Enfin il y a une balise controller qui définit sur quel controller pointe le futur lien. Il est bien sur possible de sélectionner une action avec la balise action et un module avec la balise module. C’est bien fait non ? Sinon il est possible aussi d’avoir un liens direct grâce a la balise uri. Un petit exemple qui regroupe tout les cas :

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
    <nav>
        <home>
            <label>nav_home</label>
            <controller>index</controller>
        </home>
        <page2>
            <label>Page 2</label>
            <module>mon_module</module>
            <controller>mon_controller</controller>
            <action>mon_action</action>
        </home>
        <home>
            <label>nav_home</label>
            <uri>/foo/bar/</uri>
        </home>
    </nav>
</configdata>

Bootstrap

Il faut rajouter une méthode a notre bootstrap :

/**
 * @return Zend_Navigation
 */
protected function _initNavigation() {
    $view =
    $this->bootstrap('layout')->getResource('layout')->getView();
    $config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/navigation.xml', 'nav');
    $view->navigation(new Zend_Navigation($config));
}

La seule chose a retenir ici est le premier argument de la méthode Zend_Config_Xml : c’est le chemin de notre fichier de navigation et le deuxième argument représente la balise mère de notre section de navigation dans le fichier xml. Voilà, on a notre fonction de navigation disponible dans notre application. Il suffit maintenant de l’utiliser.

Layout

Histoire de faire le plus simple possible, on va ajouter notre barre de navigation directement dans le layout, histoire de le retrouver sur toutes les pages. Il suffit de rajouter ce bout de code dans le fichier layout.phtml à l’endroit ou vous voulez que le menu s’affiche :

<?php echo $this->navigation()->menu(); ?>

Hiérarchie de pages

On va voir maintenant un exemple de fichier xml ou il y a plusieurs pages et sous pages

<?xml version="1.0" encoding="UTF-8"?>
<configdata>
<nav>
    <home>
        <label>nav_home</label>
        <controller>index</controller>
        <pages>
            <add>
                <label>nav_fact_add</label>
                <controller>fact</controller>
                <action>add</action>
            </add>
            <list>
                <label>nav_fact_list</label>
                <controller>fact</controller>
            </list>
            <calc>
                <label>nav_calc</label>
                <controller>calc</controller>
            </calc>
            <user>
                <label>nav_user</label>
                <controller>user</controller>
            </user>
            <stats>
                <label>nav_sats</label>
                <controller>stats</controller>
            </stats>
        </pages>
    </home>
</nav>
</configdata>

Voilà, **la balise a retenir **est la balise pages qui permet de définir des sous pages ou sous menu. Et bien sur on peut en imbriquer autant qu’on veut. Enfin il faut savoir que le code html des liens sur la page suit une hiérarchie de balise ul/li.

Classe css de la page en cours

Comment ajouter une classe au lien qui pointe vers la page en cours ? Et bien il suffit de rajouter ce bout de code en haut de chaque controller (dans la méthode init) :

public function init()
{
    /` Initialize action controller here `/
    $activeNav =
    $this->view->navigation()->findByController('index');
    $activeNav->active = true;
    $activeNav->setClass("active");
}

Et voilà maintenant quand on est sur une page du controller index (dans ce cas la) et bien le lien aura (entre autre) la classe active. Il suffit après de toucher au css pour ajouter un petit effet ;)

Vous en voulez encore plus ?

Fil de Navigation ou breadcrumbs

Et bien avec Zend_Navigationon peut retracer notre chemin de navigation, qui soit dit en passant est très bon en terme d’ergonomie, mais aussi en terme de référencement. Donc je vous invite vraiment à le mettre en place. Encore une fois, il suffit de rajouter une ligne de php dans le fichier layout.phtml :

<?php echo $this->navigation()->breadcrumbs()->setMinDepth(0)->setLinkLast(true)->setSeparator(" >> "); ?>

Alors on décortique le bousin :

$this->navigation()->breadcrumbs() va afficher le fil de navigation.
->setMinDepth(0) va définir si il faut ou pas afficher ce fil ; il est en accord direct avec la profondeur du xml.
->setLinkLast(true) définit si il faut ou pas mettre un liens sur le dernier fils du fil de navigation qui correspond à la page en cours
->setSeparator( » >> « ) définit par quelle chaine de caractère est séparer notre liste de liens.

Voilà, comme on a pu voir, le plus dur est de faire le fichier xml ainsi que le css des menus. Après c’est un jeux d’enfant pour avoir de beau menu ;)

Télécharger automatiquement des .torrent sur un PC Ubuntu distant

2009-09-27T00:00:00+02:00

Il m’arrive souvent de vouloir télécharger quelque chose alors que je suis en cours ou au boulot, mais c’est souvent difficile pour diverses raisons. Une solution est d’utiliser un serveur @home et de le configurer pour qu’il télécharge automatiquement des fichiers .torrent. Voici une façon de bidouiller ça ;)

Pour commencez nous allons utiliser le client BitTorrent Deluge.

Pour l’installer :

vistez le site de la doc ubuntu fr
ou si vous avez accès au dépot Universe : deluge-torrent

Une fois installé, il faut lancer deluge

Application > Internet > Deluge BitTorrent Client

Aller dans

Editer > Préférences

Puis cocher la checkox correspondant à :

Ajouter automatiquement les .torrent provenant de

Enfin, choisir le dossier dans lequel seront ajoutés les fichiers .torrent que l’on souhaite télécharger (par exemple : /home/user/torrent)

A partir de là il ne reste plus qu’à trouver un moyen d’envoyer à distance nos fichiers torrents dans le bon répertoire. les moyens sont nombreux….On peut par exemple :

utilisez un serveur FTP

Ou utilisez le script suivant, puis éditer afin de changer la variable $destination_folder en lui donnant le chemin absolu vers le répertoire de deluge que l’on a choisi précedemment.

<?php
    ini_set('display_errors', 1);
    error_reporting(-1);

    $destination_folder = '/home/arnaud/Torrent'; // A CHANGER

    $destination_folder = trim($destination_folder);
    while (strcasecmp(substr($destination_folder, strlen($destination_folder)-1,1),'/') == 0) {
        $destination_folder = substr($destination_folder,0,strlen($destination_folder)-1);
    }
    $extension = '.torrent';
    $file_tmp_name = 'tmp';

    $url = isset($_GET['url']) ? $_GET['url'] : null;

    $form = <<<EOL
<div id="form">
    <form action="index.php" method="GET">
        <label>Entrez une URL : </label>
        <input type="text" name="url" value="'.$_['url'].'"/><br/>
        <input type="submit" name ="submit" value="Get it ! "/>
    </form>
</div>
EOL;
?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
        <head>
            <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
            <title>Remote Download Section</title>
            <style>
                .spacer {width:100%; height:30px;}
                #form {width:600px; border:1px solid black;}
                form {padding-top:10px}
            </style>
        </head>
    <body>
        <center>
            <?php if (isset($url)) : ?>
                <?php
                    while (file_exists($destination_folder.'/'.$file_tmp_name.$extension)) {
                        $file_tmp_name .= ''.rand(0,9);
                    }
                    $file_name = $file_tmp_name.$extension;
                    $result = copy($post,$destination_folder.'/'.$file_name);
                    if ($result === true) {
                        echo '<h1>Téléchargement du fichier réussi</h1>';
                    } else {
                         echo '<h1>Téléchargement du fichier échoué</h1><p>L\'url fournie n\'est peut être pas correcte</p>';
                         <?php echo $form ?>
                         echo '<p>Vous pouvez également utiliser une URL de la forme : http://monserveur/index.php?trt=lien_vers_le_fichier</p>';
                    }
                ?>
            <?php else: ?>
                <h1>Remote Download Section</h1>
                    <div class="spacer"></div>
                    <?php echo $form ?>
            <?php endif ?>
        </center>
    </body>
</html>

Il faut que le script est le droit d’écrire dans le répertoire :

chmod a+w mon_repertoire

Puis copier dans /var/www/mondossier/.

Et enfin ce script vous permettra de copier les .torrent dans le bon répertoire en tapant l’url dans votre navigateur favori : http://localhost/index.php?trt=url_du_.torrent et de lancer ainsi le téléchargement du torrent dans deluge !

La meilleur solution aurait été à mon avis un petit plugin qui permettrai d’envoyer directement le .torrent depuis son navigateur internet.

Pensez également à lancer automatiquement Déluge au démarrage du PC. Pour ce faire allez dans Système > Préférences > Applications au démarrage , cliquez sur ajouter et saisissez /usr/bin/deluge dans le champs « Commande » .

Voila, on peut maintenant télécharger son film du soir quand on y pense au boulot :p

Zend Framework 1.9 : Comment lier une feuille de style css ou un js au layout

2009-09-24T00:00:00+02:00

Comment lier un css et un js dans un projet zend framework (a partir de la 1.9) directement dans le layout ?

Et bien a partir de la version 1.9, c’est vraiment très simple dans la mesure ou l’équipe de ZF a intégré un script de vue (view helper) directement dans la librairie. Du coup il suffit de rajouter la ligne suivante dans le fichier de layout (application/layout/scripts/main.phtml), entre les balises :

<link rel="stylesheet" type="text/css" media="screen,projection" href="<?php echo $this->baseUrl();?>/styles/design.css"/>

Dans ce cas, mon fichier css est dans le dossier : public/styles/design.css

Voila, maintenant pour un js c’est le même principe ;) :

<script type="text/javascript" src="<?php echo $this->baseUrl();?>/styles/main.js"></script>

Comment mettre en place un backup sur son serveur dedié ?

2009-07-24T00:00:00+02:00

Comment mettre en place un système de backup automatique sur son serveur dédié qui tourne sous linux ? Et bien rien de bien compliqué, il suffit de lire ce qui va suivre pour s'auvegarder les dossiers que vous voulez : /home, les svn, les bases de données etc ...

Il y a un petit outils qui va quasiment faire tout le travail pour nous : backup-manager Tuto sur le site d'Ubuntu-Fr. Je me suis insipiré de ce tuto pour ecrire celui que vous etes en train de lire.

Pour utiliser ce logiciel, et facon plus général, il vaut mieux etre en root pour effectuer toute le prochaine opération. on passe donc en root :

sudo su

Comment sauvegarder les répertoires ?

Alors on commence par installer backup manager :

apt-get install backup-manager

Ensuite il faut répondre aux différente questions (de tête, je ne m’en souvient plus) :

Emplacement du répertoire de sauvergarde
Emplacement des repertoires a sauvegarder
Utilisateur qui sauvergarde
Droit des fichiers sauvegarder

Si vous ne savez pas quoi mettre laissez les options par default. Par contre si vous voulez modifier ces options, on peut refaire la configuration, de facon plus complète avec plus d’options :

dpkg-reconfigure backup-manager

Allez on y va ensemble : donc on saisi :

Le chemin du dossier qui recevra les archives
L’utilisateur propriétaire du dossier
Son groupe
Le type de compression
La fréquence des sauvegarde
Si il faut ou pas suivre les liens symbolique. Laisser a non sauf si vous etes vraiment sur de vous.
Le format de nommage des archives
La durée de vie des archives : la ça sert a rien de garder les archives pendant plus d’une semaine…
Les répertoires à sauvegarder.
Les répertoires à exclure (oui oui celui ou y’a des vidéos nsfw)
Si il faut ou non chiffre les archives, normalement y’en a pas besoin. Sauf si la sauvegarde est expédié sur le serveur d’un copain.
Si il faut envoyer les archives sur un autre serveur (ftp ssh). Je n’ai pas d’autre serveur, donc non.
Si il faut graver un cd. Je suis sur un dédié qui est 300km de chez moi, donc non

Voila, donc a ce moment la il ne nous sauvegarde que nos repertoire /home et /etc si vous avez laisser les options par default.

Comment sauvegarder les bases de données ?

Mais je veux qu’il me sauvegarde aussi mes bases de donnée : Pour ce faire il suffit d’éditer un fichier :

nano /etc/backup-manager.conf

Et de reperer les lignes suivante et les modifier :

# If you don't want to use any backup method (you don't want to
# build archives) then choose "none"

# Version de base

#export BM_ARCHIVE_METHOD="tarball mysql"

#Pour la gestion de la base de donnée

export BM_ARCHIVE_METHOD="tarball mysql"

## [...] ## => la suite est vers la fin du fichier. Il suffit de renseigner les déférents champs.

##############################################################
# Backup method: MYSQl
#############################################################

# This method is dedicated to MySQL databases.
# You should not use the tarball method for backing up database
# directories or you may have corrupted archives.
# Enter here the list of databases to backup.
# Wildcard: __ALL__ (will dump all the databases in one archive)
export BM_MYSQL_DATABASES="__ALL__"

# The best way to produce MySQL dump is done by using the "--opt" switch
# of mysqldump. This make the dump directly usable with mysql (add the drop table
# statements), lock the tables during the dump and other things.
# This is recommended for full-clean-safe backups, but needs a
# privileged user (for the lock permissions).
export BM_MYSQL_SAFEDUMPS="true"

# The user who is allowed to read every databases filled in BM_MYSQL_DATABASES
export BM_MYSQL_ADMINLOGIN="root"

# its password
export BM_MYSQL_ADMINPASS=""

# the host where the database is
export BM_MYSQL_HOST="localhost"

# the port where MySQL listen to on the host
export BM_MYSQL_PORT="3306"

# which compression format to use? (gzip or bzip2)
export BM_MYSQL_FILETYPE="bzip2"

Et voila, on a maintenant un backup de notre serveur dans le dossier */var/archives/`. Il faut savoir qu’on peut aussi sauvegarder des svn. et qu’on peut exporter le tout sur un autre serveur par exemple. Les protocoles supporter sont :

scp
ssh-gpg
ftp
rsync
s3

Comment je recupere toutes les archives ?

Comme je vous l’ai dit, je n’ai pas d’autre serveur sous la main. Donc je me suis fait un petit script (.sh) que je peux lancer a la main :

#!/bin/bash
ssh root@SERVEUR "tar -c /var/archives/`" > /CHEMIN/VERS/LE/DOSSIER/DE/RECEPTION/archives-$(date +%d%m%Y).tar

et voila on a plus qu’a rendre ce script executable et a l’exécuter, et le tour et jouer :

chmod +x getBackup.sh
./getBackup.sh

Et voila le tour est jouer. on a notre serveur qui fait des backups tout les jours, et vous du coté client il n’y a plus qu’a exécuter le script tous les jours...

Comment mettre en place un Layout avec le Zend-Framework 1.8

2009-07-23T00:00:00+02:00

On va voir ensemble comment utiliser les Layouts, placeholder, helper dans le** Zend Framework** 1.8 (et supérieur). En effet, depuis la version 1.8, la gestion n’est plus automatique, mais en 2 temps 3 mouvements c’est réglé.

Qu’est ce qu’un Layout ?

Un layout est un template, ou alors un squelette vide de votre site. Il n’y a aucun contenu, il n’y a presque que du code HTML. Les layouts sont très pratique, car ils permettent de ne pas avoir copier / coller tout le code html identique sur chaque pages. On peut donc faire des templates par defaut pour un grand nombre de page.

Dans tous les cas, un script de layout est nécessaire. Les scripts de layout utilisent simplement Zend_View (ou une implémentation particulière personnalisée). Les variables de layout sont enregistrées dans le placeholder Layout, et peuvent être accédées via l’aide de vue placeholder ou directement en tant que propriétés de l’objet layout.

D’après la documentation de Zend Framework

Sommaire

Sommaire
Exemple de layout ou template général
Mise en place du Layout
Comprendre les placeholders et les helpers
C’est quoi un helpers ou Script de Vue ?
C’est quoi un placeholders ?
Comment Utiliser un placeholders ?
Comment faire pour changer le titre de ma page ?
Explication : Implementation d’un placeholders dans un helper

Exemple de layout ou template général.

Voici un exemple de template :

On voit qu’on a diviser notre gabarit de page en quatre zones (complètement arbitrairement) :

En haut : le Header
En bas : le Footer
A gauche : le menu de navigation
A droite : le contenu

Voici ce qu’est un layout : le layout c’est la partie qui ne change pas : Header, Footer, Menu.

Mise en place du Layout.

Il faut commencer par choisir un emplacement pour les fichiers. Moi j’ai choisit APPLICATION_PATH "/layouts/scripts" (par défaut, cf la doc de Zend). Dans ce dossier on va créer notre premier layout, qu’on appellera : layouts.phtml. L’extension .phtml est l’extension standard pour les layouts dans zend.

Une fois ce fichier créé, il faut renseigner à zend qu’on va utiliser un layout. On va donc ajouter au fichier de configuration application.ini ces quelques lignes :

LAYOUT
resources.layout.layout = "layout"
resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

Grâce a ces deux lignes, Zend va automatiquement chercher le script /layouts/scripts/layout.phtml et l’utiliser. A partir de ce moment, le script de vues devient plus leger, avec seulement un partie du code html. Donc pour résumer : Dans le layout, il y a beaucoup de HTML (balise html, head, title, body) et dans les vues un peu plus de php et peu moins de html. OK ? Si vous avez un doute sur les view (vue) c’est ici, et sur les controllers c’est la.

Maintenant on peut encore plus customiser (personnaliser) notre layout. Comme lui mettre une titre par défaut, choisir son encodage, choisir son doc type etc… Tout ce fait dans le bootstrap :

/**
 * Initialize session
 *
 * @return Zend_View
 */
protected function _initView()
{
    // Initialize view
    $view = new Zend_View();
    $view->doctype('XHTML1_STRICT');
    $view->headTitle('Ma premiere application avec Zend');
    $view->headMeta()->appendHttpEquiv('Content-Type', 'text/html; charset=UTF-8');
    // Add it to the ViewRenderer
    $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
    $viewRenderer->setView($view);
    // Return it, so that it can be stored by the bootstrap

    return $view;
}

Enfin il faut faire le fichier layouts.phtml

<?php echo $this->doctype() ?>
<html>
    <head>
        <?php echo $this->headTitle() ?>
        <?php echo $this->headLink() ?>
        <?php echo $this->headStyle() ?>
        <?php echo $this->headScript() ?>
        <?php echo $this->headMeta() ?>
    </head>
    <body>
        <?php echo $this->layout()->content ?><br />
    </body>
</html>

Voila on a notre Layout en place. Maintenant, il s’agit de comprendre comment il fonctionne.

Comprendre les placeholders et les helpers.

Si vous avez bien suivi le Tutos, vous avez vu que dans le bootstrap on a déjà mis des valeurs par défault. Ces valeurs, normalement c’est la vue (view) qui les passe aux layouts. Dans notre cas, le bootstrap crée en avance le layout (je rappel que presque tout est objet). Néanmoins il reste bien évidemment possible de changer ces valeurs.

C’est quoi un helpers ou Script de Vue ?

D’après la documentation de Zend :

Dans vos scripts de vue, il est souvent nécessaire d’effectuer certaines actions complexes encore et encore : par exemple, formater une date, générer des éléments de formulaire, afficher des liens d’action. Vous pouvez utiliser des classes d’aide pour effectuer ce genre de tâches.

Petite traduction : un helper va être une classe que l’on va utiliser souvent dans les vues. Il évite les taches répétitives. Par exemple une zone pour savoir si l’utilisateur est loggué. Par contre la je vais vous laisser voir les exemple directement sur la doc de Zend. D’ailleur on verra prochainement comment faire un helper pour vérifier si la personne est loggué.

C’est quoi un placeholders ?

D’après la documentation de zend :

L’aide de vue Placeholder est utilisé pour faire persister le contenu entre les scripts de vues et les instances de vues. Il offre aussi des fonctionnalités utiles comme l’agrégation de contenu, la capture de contenu de scripts de vues pour une utilisation ultérieure, et l’ajout de texte pré ou post contenu (et la personnalisation des séparateurs de contenu).

Petite traduction. Les Placeholders sont des genres de variables. On les utilises pour faire passer du code HTML mis en forme (la pluspart du temps) depuis la vue vers le layout. Vu que le layout est générique, il faut savoir rester général sur les noms des placeholders. Enfin les placeholders sont persistants : c’est a dire qu’on peut les utilisers dans une première vue, puis dans une autre vue ou dans un autre script…

Comment Utiliser un placeholders ?

Dans le layout, le placeholder s’utilise de cette façon :

<?php echo $this->placeholder('PH1');?><br />
<?php echo $this->placeholder('PH2');?><br />
<?php echo $this->placeholder('PH3');?><br />

Pour le layout, il n’y a pas 15 000 facon de les utiliser. Par contre dans une vue, on peut les utilisers de plusieurs facon :

Comme une variable :

$this->placeholder('PH1')->set("j'utilise mon placeholder PH1");

Comme un agrégateur de variables, avec plein d’outils mis a disposition.

$this->placeholder('PH2')->exchangeArray(array(1,2,3));
$this->placeholder('PH2')->setPrefix("<ul>n <li>")
     ->setSeparator("</li><li>n")
     ->setIndent(4)
     ->setPostfix("</li></ul>n");

La on decoupe notre tableau gràce a la fonction exchangeArray. Puis on rajoute des balise html avant et après. Le code parle de lui même.

Comme un agrégateur de contenu

<?php $this->placeholder('PH3')->captureStart(); ?>
    La on utilise notre<br>
    Placeholders PH3<br>
    qui est sur plusieurs lignes <br />
    Et qui contient des balises html, ca ne dérange pas.
<?php  $this->placeholder('PH3')->captureEnd(); ?>

La on utilise des méthodes qui vont commencer la capture puis terminer la capture. Tout ce qui sera entre ces deux méthodes seront contenue par le placeholder.

Enfin il faut savoir qu’il existe un bon nombre de configurations pour les placeholders. Je vous conseil de regarder la doc. On peut y apprendre a identer le code, ajouter des préfix, suffix etc…

Comment faire pour changer le titre de ma page ?

Voila le code, je vous l’explique après :

$this->headTitle('Mon nouveau titre','SET');

Explication : Implementation d’un placeholders dans un helper

Alors la je vous est perdu sur le titre. en fait ce n’est que pour les puristes et ceux qui veulent tout savoir que je l’ai ecrit comme ca. Sinon la on met met juste le titre de notre page en argument de la méthode headTitle. Mais d’ou vient ce « SET »‘. Et bien sans SET, par défault les méthodes head**| ajoute le code a la fin de ce qu’il y a deja. Ce qui est extremement pratique pour les CSS et JS (cf la prochaine note). Mais on peut aussi écraser la valeur du titre, ajouter le nouveau avant ou après etc… Alors pourquoi « Implementation d’un placeholders dans un helper ». Et bien en fait dans zend il existe déjà beaucoup de helper (comme vu plus haut), vous les utiliser mais vous ne le savez peut etre pas. Ensuite, headtitle par exemple est un placeholders, certe particulier, mais c’en est un. Voila vous savez tout !!

Sortie de la beta 1.9 de Zend Framework

2009-07-23T00:00:00+02:00

Zend Framework 1.9.0 vient de sortir en beta. Youpi. On peut la trouver la : http://framework.zend.com/download/latest

Bon en gros ils nous disent quoi les gars de chez Zend ? Que c’est uneversion non-stable, et qu’on ne la trouve pas encore sur le site. Sinon ils ont beaucoup travaillé sur la stabilité, les tests etc... Et tant mieux. Sinon pour les nouveautés : support de la version 5.3 de php.

Les autres nouveautés en pagaille (on aura l’occasion d’y revenir) :

Zend_Rest_Route, Zend_Rest_Controller, and Zend_Controller_Plugin_PutHandler, which aid in providing RESTful resources via the MVC layer.
Zend_Feed_Reader, which provides a common API to RSS and Atom feeds, as well as extensions to each format, caching, and a slew of other functionality.
Zend_Queue and Zend_Service_Amazon_Sqs, which provide the ability to use local and remote messaging and queue services for offloading asynchronous processes.
Zend_Db_Table updates to allow using Zend_Db_Table as a concrete class by passing it one or more table definitions via the constructor.
Zend_Test_PHPUnit_Db, which provides Zend_Db support for PHPUnit’s DBUnit support, allowing developers to do functional and integration testing against databases using data fixtures.
Annotation processing support for Zend_Pdf, as well as performance improvements.
Zend_Dojo custom build layer support.
Numerous Zend_Ldap improvements.
Zend_Log_Writer_Syslog, a Zend_Log writer for writing to your system log.
Several new view helpers, including Zend_View_Helper_BaseUrl.

Initialisation d'un projet Zend Framework Avec Zend_Tool

2009-07-13T00:00:00+02:00

On a deja vu pas mal de chose sur le Zend Framework, mais depuis la version 1.8.`, il y a quelques petites choses qui ont changées, comme l’architecture, et l’arrivée de Zend_Tool.

C’est quoi Zend_Tool ? c’est un script php qui s’exécute en mode console (CLI) et qui nous permet de créer une base pour notre application :

L’architecture du projet
Un nouveau controller
Une nouvelle action
Une nouvelle vue
Un nouveau module
etc …

On va donc recréer notre application de gestion de budget grâce aux Zend_Tools. Pour faire les choses proprement, on va commencer par télécharger la dernière version de Zend Framework (1.8.4). Vous la dé- zipper ou vous voulez sur votre disque dur. Dans mon cas, c’est /home/lyrix/Prog/php/2009/ZendFramework-1.8.4. Maintenant il va falloir inclure ce path dans notre include path. c’est a dire qu’il nous sera possible d’appeler zf.sh (ou zf.bat pour les windowsiens) depuis n’importe quels répertoires depuis notre console favorites. Sinon sous Linux on peut faire plus simple, on va tout simplement faire un alias :

alias zf.sh=/home/lyrix/Prog/php/2009/ZendFramework-1.8.4/bin/zf.sh

Note : Si vous faites ce code directement depuis la console, l’alias sera temporaire (juste pour cette console), si vous le faite dans le fichier ~/.bashrc, l’alias sera permanent.

Voila maintenant il nous faut créer ce projet dans le dossier qui va bien. Moi je veux le mettre la : /home/lyrix/Prog/php/2009/Budget/ donc je me place dans ma console dans le dossier /home/lyrix/Prog/php/2009/ puis je crée mon projet :

cd /home/lyrix/Prog/php/2009/ zf.sh create project Budget

Voila notre projet est crée. On peut aussi faire des modules, pour ce faire il faut aller se placer dans le projet en question, et créer un module :

cd /home/lyrix/Prog/php/2009/Budget zf.sh create module Frontend

Voila, notre structure du projet est crée. Il faut maintenant coller la librairie librairie dans /home/lyrix/Prog/php/2009/Budget/library. (On doit copier tout le dossier Zend). Sous linux on peut aussi faire un lien symbolique directement vers un autre dossier de son disque dur. :

cd /home/lyrix/Prog/php/2009/Budget/library
ln -s /home/lyrix/Prog/php/2009/ZendFramework-1.8.4/library/Zend/ Zend

Voila notre projet fonctionne, on peut se rendre a la page suivante pour voir le résultat :

http://127.0.0.1/monwww/2009/Budget/public/

Enfin, je rappel qu’il est quand meme possible de creer l’architecture d’un projet directement dans Zend Studio. Il suffit de faire un nouveau projet et se laisser guider.

On peut passer a l’architecture de Zend Framework

Architecture de Zend Framework 1.8 en MVC

2009-07-13T00:00:00+02:00

Voila, on vient de voir comment faire un nouveau projet avec le Zend_Tool. Comme j’expliquai dans le précédant article, l’architecture de Zend Framework a un petit changé. Voila la nouvelle Architecture :

ZfProject
- Application : contient toute l’application, en générale ce dossier ce situe a un endroit de votre serveur qui n’est pas accessible depuis l’extérieur (comme dans les CGI-BIN)
  - config : Contient tous les fichiers de configuration de l’application
    - application.ini : on retrouve tous les configuration de votre application (BDD, php.ini etc)
  - controllers : ce sont les controlleurs (le C de MVC). ce sont eux qui vont creer des models pour excecuter des actions, des taches ou des opérations, ils founissent ensuite le ou les résultats à la vue.
  - models : ce sont les models de votre application. Ce sont des class php qui vont faire le « gros » du travail
  - view : ce sont le vues de votre applications. On y retrouve :
    - helpers : des bouts de code commun que l’on peu aussi utiliser dans les layouts
    - scripts : les vrais vues. Ici il faut respecter une structure precise, en accord avec les controllers, mais on y reviendra
  - bootstrap.php est le fichier de chargement de l’application. c’est dans le bootstrap qu’on fait les connections a la base de donnée par exemple.
- library : ici on a toutes les class dont zend a besoin pour fonctionner, et on a aussi toutes les autres class disponible (voir la doc …)
- public : c’est le dossier public qui est accessible depuis l’extérieur : on y retrouve toutes les feuilles de style, les fichiers javascripts, les images …
- test : ce dossier contient toutes les class qui servent a faire des tests unitaire.

Ici on est dans une architecture ou l’on utilise pas de modules, avec des modules, la structure est un tout petit peux différente. Je pense que l’image parle d’elle même… Sinon je n’ai développer que le dossier modules, le reste restant identique.

On peut passer au bootstrap de Zend Framework 1.8

Introduction a Zend Framework 1.8 en MVC

2009-07-13T00:00:00+02:00

On va voir comment transformer un script php qui n’utilise pas Zend en une application utilisant le Framework Zend. Pour se faire on va utiliser la version 1.8 (ou supérieur) de Zend Framework, et on va l’utiliser en mode MVC (Model View Controller).

Il va d’abord falloir faire les bases : création de project, structure, bootstrap.

Voila une fois que le début de l’application est préparer on part sur une base solide. On va donc voir comment marche les Controleurs, les Vues, et les Models, on pourra aussi voir comment se servir des css et du javascript avec zend (pour Zend Framework 1.7).

On va donc partir des sources de l’application que j’ai deja faite pour la gestion du budget commun dans une colocation, et on va essayé de l’adapté à Zend.

Tuto : Zend Framework 1.8 et son bootstrap

2009-07-13T00:00:00+02:00

Voila, on va voir comment fonctionne le Boostrap de la version 1.8 de Zend Framework. Par default le fichier Bootsrap.php est presque vide. Il ne contient que ces quelques lignes :

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{

}

Mais on va voir ensemble comment construire notre bootstrap

Sommaire

Sommaire
Comment fonctionne le bootstrap
Mise en place du fichier de configuration
Connexion a la base de données
Mise en place des sessions
Mise en place de modules
Conclusion

Comment fonctionne le bootstrap ?

**Mais a quoi sert le bootstrap** ? Lebootstrap`, c’est le fichier qui va être lancé au début de l’application et qui va s’occuper d’exécuter toutes les petites routines, de faire les connections aux bases de données, d’instancier toutes les constantes, les sessions, les modules, les layouts etc …

Par défaut le bootstrap fonctionne même si il est vide, mais on peut faire en sorte de le customiser un peu. Comment faire ? Déjà le fichier index.php qui est le premier a être exécuter (dans le dossier public) va lancer la méthode run du bootstrap. On peut alors créer cette méthode. Ensuite il faut savoir que le bootstrap hérite de Zend_Application_Bootstrap_Bootstrap qui lui est magique (On va y revenir). Donc si on redéfinit la méthode run, il ne faut pas oublier d’appeler la methode run de la class : Zend_Application_Bootstrap_Bootstrap.

public function run()
{
    parent::run();
}

On peut ensuite créer plusieurs méthodes pour par exemple faire les connections aux bases de données, initialiser les sessions etc. Et c’est la que le bootstrap est magique : il suffit de déclarer les méthodes en protected et de mettre un underscrore (_) devant le nom de la méthode, et celle-ci sera directement exécuter.

Si on regarde le code de la méthode run de la class Zend_Application_Bootstrap_Bootstrap, on voit que par défaut on n’utilise pas de module. Il est possible d’utiliser les modules, mais on verra ça plus tard. Donc par défaut il faut respecter l’architecture « normale ».

Mise en place du fichier de configuration.

Comme on a vu dans l’architecture du zend framework, il y a deja un fichier de configuration, mais par défaut il n’est pas vraiment utilisable. Je m’explique : quand on démarre l’application, celle ci utilise bien le fichier de configuration. Mais si a un moment ou a un autre on a besoin de ce fichier, il sera compliqué d’utiliser les constantes définit. Par défaut le fichier de config ressemble a celui la :

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

[staging : production]

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

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

Celui ci est basé sur un model orienté objet. Je vous conseil de lire le manuel de Zend si vous êtes un peu perdu : http://zendframework.com/manual/fr/zend.config.adapters.ini.html.

On va donc faire en sorte de pouvoir utiliser ce fichier depuis n’importe ou depuis l’application. On va utiliser la Zend_Registry. C’est quoi Zend_Registry ? C’est un registre (un zone mémoire sur le serveur) ou l’on va pouvoir stocker toutes sorte de choses : constante, pointeurs vers des bases de données etc… On ajoute donc notre fichier de config (qui sont en faites les options (parametres) du bootstrap) à un registre config :

public function run()
{
    // Cela permet d'avoir le fichier de configuration disponible depuis
    n'importe ou dans l'application.
    Zend_Registry::set('config', new Zend_Config($this->getOptions()));
    parent::run();
}

Connexion a la base de données

Pour se faire on va utiliser les données du fichier de configuration : application.ini. On va le convertir en vrai fichier de configuration grâce a Zend_Config, puis on va le donnée a Zend_Db qui va nous faire une factory de notre base de donnée. C’est grâce a cette factory qu’on pourra excécuter des requetes directement sur la base de donnée.

resources.db.adapter ="MYSQLI"
resources.db.params.host = "localhost"
resources.db.params.username = "budget2"
resources.db.params.password = "budget2"
resources.db.params.dbname = "budget2"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Pour les variables du fichier de configuration, vous pouvez vous référer au manuel de Zend Framework.

/**
* Initialize data bases
*
* @return Zend_Db::factory
*/
protected function _initDb()
{
    //on charge notre fichier de configuration
    $config = new Zend_Config($this->getOptions());
    //On essaye de faire une connection a la base de donnee.
    try{
         $db = Zend_Db::factory($config->resources->db);
         //on test si la connection se fait
         $db->getConnection();
     }catch ( Exception $e ) {
         exit( $e -> getMessage() );
     }
     // on stock notre dbAdapter dans le registre
     Zend_Registry::set( 'dba', $db );

     return $db;
}

Enfin on met cette factory dans un registre de manière a pouvoir l’utiliser depuis n’importe ou dans l’application.

Note : On créer ici une connection a la base de donnée qui pourra etre utilisé depuis n’importe quelle partie de l’application. Cependant on verra qu’en regle général, on ne fait pas directement de requete sur la base de donnée, on utilise des models pour se faire …

Initialisation des sessions :

On va mettre en place les sessions tout de suite : c’est assez simple. Je pense que le code parle de lui meme.

/**
 * Initialize session
 *
 * @return Zend_Session_Namespace
 */
protected function _initSession()
{
    // On initialise la session
    return new Zend_Session_Namespace('budget', true);
}

Mise en place de modules :

Une bonne partie de la déclaration d’un module par défault va se faire directement dans le fichier de configuration :

#initialize front
controller resource
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
resources.frontController.defaultControllerName = "index"
resources.frontController.defaultAction = "index"
resources.frontController.defaultModule = "Frontend"

Et une autre partie dans le bootstrap :

/**
* Initialize Module
*
* @return Zend_Application_Module_Autoloader
*/
protected function _initAutoload()
{
    $loader = new Zend_Application_Module_Autoloader(array(
        'namespace' => '',
        'basePath'  => APPLICATION_PATH,
    ));

    return $loader;
}

Note : Cependant, si quelqu’un connait bien ZF, j’aimerais avoir une renseignement, car il me semble que le code du bootsrap soit facultatif …

Conclusion :

Voila, on commence a avoir un bon bootstrap qui tient la route, mais on verra par la suite qu’on peut rajouter beaucoup de chose dans ce bootstrap, comme par exemple l’utilisation des layouts …

N’hesitez par a aller faire une tours sur le site de ZF – page application

On retrouve les deux fichiers :

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    public function run()
    {
        // Cela permet d'avoir le fichier de configuration disponible depuis n'importe ou dans l'application.
        Zend_Registry::set('config', new Zend_Config($this->getOptions()));

        parent::run();
    }

    /**
    * Initialize Module
    *
    * @return Zend_Application_Module_Autoloader
    */
    protected function _initAutoload()
    {
        $loader = new Zend_Application_Module_Autoloader(array(
            'namespace' => '',
            'basePath' => APPLICATION_PATH
        ));

        return $loader;
    }

    /**
    * Initialize data bases
    *
    * @return Zend_Db::factory
    */
    protected function _initDb()
    {
        //on charge notre fichier de configuration
        $config = new Zend_Config($this->getOptions());

        //On essaye de faire une connection a la base de donnee.
        try{
             $db = Zend_Db::factory($config->resources->db);
             //on test si la connection se fait
             $db->getConnection();
        }catch ( Exception $e ) {
            exit( $e -> getMessage() );
        }

        // on stock notre dbAdapter dans le registre
        Zend_Registry::set( 'dba', $db );

        return $db;
    }

    /**
     * Initialize session
     *
     * @return Zend_Session_Namespace
     */
    protected function _initSession()
    {
        // On initialise la session
        $session = new Zend_Session_Namespace('budget', true);

        return $session;
    }
}

Et:

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

#initialize front controller resource
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
resources.frontController.defaultControllerName = "index"
resources.frontController.defaultAction = "index"
resources.frontController.defaultModule = "Frontend"

[staging : production]

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

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

#DATABASE
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "budget2"
resources.db.params.password = "budget2"
resources.db.params.dbname = "budget2"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Zend framework : Initializer et boot strap

2009-06-30T00:00:00+02:00

UPDATE du 22/07/2009 :

Il y a une mise a jour de ce tuto ici.

Avant d’aller plus loin dans notre série de tutos, il faut d’abord qu’on règles les fichier boostrap, et l’initializer. Ce sont deux fichiers qui s’occupe de démarrer notre application. C’est dans ces fichiers qu’on va définir toutes nos constantes de l’application, comme les paramètres pas défaut de l’application, les sessions, et surtout la connexion à la base de données.

Petite précision : l’initializer et le bootstrat ne sont plus d’actualité dans la version 1.8. Cependant cette méthode fonctionne toujours. On va donc voir la méthode de Zend Framework 1.7. Ca ne pose pas de problème, les deux méthodes sont très similaire. Dans Zend 1.8, l’initializer et le bootstrap ont été réuni. J’essayerais de faire un update de ce tutos des que possible. De plus l’architecture de la 1.8 a aussi un peu changé. J’essayerais aussi de mettre a jour ce tutos.

Bootstrap

De base notre bootstrat ressemble a ça :

/**
 * My new Zend Framework project
 *
 * @author
 * @version
 */
set_include_path('.' . PATH_SEPARATOR . '../library' . PATH_SEPARATOR . '../application/default/models/' . PATH_SEPARATOR . get_include_path());

require_once 'Initializer.php';
require_once "Zend/Loader.php";

// Set up autoload.
Zend_Loader::registerAutoload();

// Prepare the front controller.
$frontController = Zend_Controller_Front::getInstance();

// Change to 'production' parameter under production environemtn
$frontController->registerPlugin(new Initializer('development'));

// Dispatch the request using the front controller.
$frontController->dispatch();

La seule chose importante ici est la ligne :

$frontController->registerPlugin(new Initializer('development'));

Ici on crée un nouvel Initializer avec comme paramètre, le nom de l’environnement (par exemple development, production, test etc…)

Initializer

On peut donc passer a l’initializer (c’est la version final):

/**
 * My new Zend Framework project
 *
 * @author
 * @version
 */

require_once 'Zend/Controller/Plugin/Abstract.php';
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Controller/Request/Abstract.php';
require_once 'Zend/Controller/Action/HelperBroker.php';

/**
 *
 * Initializes configuration depndeing on the type of environment
 * (test, development, production, etc.)
 *
 * This can be used to configure environment variables, databases,
 * layouts, routers, helpers and more
 *
 */
class Initializer extends Zend_Controller_Plugin_Abstract
{
    /**
     * @var Zend_Config
     */
    protected static $_config;

    /**
     * @var string Current environment
     */
    protected $_env;

    /**
     * @var Zend_Controller_Front
     */
    protected $_front;

    /**
     * @var string Path to application root
     */
    protected $_root;

    /**
     * Constructor
     *
     * Initialize environment, root path, and configuration.
     *
     * @param string $env
     * @param string|null $root
     * @return void
     */
    public function __construct($env, $root = null)
    {
        $this->_setEnv($env);
        if (null === $root) {
            $root = realpath(dirname(__FILE__) . '/../');
        }
        $this->_root = $root;

        $this->initPhpConfig();

        $this->_front = Zend_Controller_Front::getInstance();

        // set the test environment parameters
        if ($env == 'test') {
                // Enable all errors so we'll know when something goes wrong.
                error_reporting(E_ALL | E_STRICT);
                ini_set('display_startup_errors', 1);
                ini_set('display_errors', 1);
                $this->_front->throwExceptions(true);
        }
    }

    /**
     * Initialize environment
     *
     * @param string $env
     * @return void
     */
    protected function _setEnv($env)
    {
        $this->_env = $env;
    }

    /**
     * Initialize Data bases
     *
     * @return void
     */
    public function initPhpConfig()
    {

    }

    /**
     * Route startup
     *
     * @return void
     */
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->initConfig();
        $this->initDb();
        $this->initHelpers();
        $this->initView();
        $this->initPlugins();
        $this->initRoutes();
        $this->initControllers();
    }

    public function initConfig(){
        // On charge Les configs global de l'application et on les met dans un registre
        $config = new Zend_Config_Ini($this->_root . '/application/default/config/config.ini');
        // On met notre fichier de config dans un registre.
        Zend_Registry::set('config', $config);
    }

    /**
     * Initialize data bases
     *
     * @return void
     */
    public function initDb()
    {
        //on charge notre fichier de config
        $config = Zend_Registry::get('config');
        try{
            $db = Zend_Db::factory($config->database);
            //on test si la connection se fait
            $db->getConnection();
        }catch ( Exception $e ) {
            exit( $e -> getMessage() );
        }
        // on stock notre dbAdapter dans le registre
        Zend_Registry::set( 'dba', $db );
    }

    /**
     * Initialize action helpers
     *
     * @return void
     */
    public function initHelpers()
    {
        // register the default action helpers
        Zend_Controller_Action_HelperBroker::addPath('../application/default/helpers', 'Zend_Controller_Action_Helper');
    }

    /**
     * Initialize view
     *
     * @return void
     */
    public function initView()
    {
        // Bootstrap layouts
        Zend_Layout::startMvc(array(
            'layoutPath' => $this->_root .'/application/default/layouts',
            'layout' => 'main'
        ));

    }

    /**
     * Initialize plugins
     *
     * @return void
     */
    public function initPlugins()
    {

    }

    /**
     * Initialize routes
     *
     * @return void
     */
    public function initRoutes()
    {

    }

    /**
     * Initialize Controller paths
     *
     * @return void
     */
    public function initControllers()
    {
        $this->_front->addControllerDirectory($this->_root . '/application/default/controllers', 'default');
    }
}

On a plusieurs variables qui représente des objets important pour zend : l’environnement, la configuration, le front controller etc. On peux en ajouter a la main, comme un gestionnaire de session par exemple. On voit que dans l’initalizer on peut appeler la méthode initPhpConfig qui nous permet de changer au démarrage de l’application les variables ini de php (ini_set(‘display_startup_errors’, 1);) par exemple. Ensuite on la méthode routeStartup qui s’exécute. Qui elle même se charche d’exécuter toutes les routines de démarrage de l’application. Celle qui nous intéresse en premier va etre initDb, mais avant il va falloir qu’on gère un fichier de configuration (de la BDD entre autre). Cela va se faire grâce a Zend_Config et grace a Zend_Registry.

Fichier de configuration, et stockage de celui ci (Zend_Config, Zend Registry)

Tout d’abord on crée notre fichier de config dans : Budget/application/default/config.

[database]
adapter = "pdo_mysql"
params.host = "localhost"
params.username = "budget2"
params.password = "budget2"
params.dbname = "budget2"

Dans ce fichier on y met les information concernant l’accès a la base de donnée. Dans mon cas, j’ai budget2se conneclocalhostubudget2motbudget2our l’adaptateur, si vous êtes sur mysql, laissez pdo_mysql, sinon referez vous a la doc.

Maintenant il va falloir faire récupérer les informations du fichier de config et le mettre dans un registre. Un registre est une zone ou l’on peut stocker des variables de façon persistante, c’est a dire d’une page a l’autre. Attention, c’est n’est pas une session, il ne faut utiliser les registres que pour les données de l’application et non les données des utilisateurs.

On ajoute donc dans la méthode routeStartup de l’initializer, en première ligne, un appel la méthode initConfig : $this->initConfig(); Et bien sur on crée cette méthode :

public function initConfig(){
    // On charge Les configs global de l'application et on les met dans un registre
    $config = new Zend_Config_Ini($this->_root . '/application/default/config/config.ini');
    // On met notre fichier de config dans un registre.
    Zend_Registry::set('config', $config);
}

On peut maintenant coder notre méthode : initDb.

Configuration de la base de données

La on récupère notre fichier de config, et on crée une nouvelle db_factory. On teste au passage si la connexion est bien valide. Puis on ajoute ce connecteur a la base de donné dans un registre qu’on nomera dba, comme Data Base Adaptater.

public function initDb()
{
    //on charge notre fichier de config
    $config = Zend_Registry::get('config');
    try{
         $db = Zend_Db::factory($config->database);
         //on test si la connection se fait
         $db->getConnection();
     }catch ( Exception $e ) {
         exit( $e -> getMessage() );
     }
     // on stock notre dbAdapter dans le registre
     Zend_Registry::set( 'dba', $db );
}

Voila on a notre connexion a la base de donnée, que l’on pourra appeler depuis n’importe quelle fonction.

Il est possible de configurer plein d’options dans l’initializer, je ne vais pas m’attardé dessus, il y a la doc pour ca. Par contre dans la mise a jour de cet article, j’essayerai d’aller plus loin.

Zend : Comment utiliser un model ?

2009-06-27T00:00:00+02:00

On va voir comment se servir d’un model dans Zend framework. Un model est en fait un objet que vous allez pouvoir utiliser. Il est bien sur possible d’en utiliser plusieurs, et d’appeler un model depuis un autre model. Il est possible d’utiliser dans les models des models du framework zend comme Zend_Registry, Zend_ProgressBar, les Zend_Service_ etc. Il est aussi possible d’étendre une class du framework, comme la class Zend_DB. On peut se reférer a la documentation de Zend.

Cependant, les models doivent respecter une certaine syntaxe pour le nom du fichier, et aussi pour le nom de la class. Si un model est directement dans la dossier models, le nom de fichier devra etre : Nom.php et le nom de class devra etre Nom. En gros il faut que le nom de class et le nom de fichier soient les memes. Par contre, si la class est dans un sous dossier du dossier model, la il faudra que le nom du fichier soit NomDeFichier.php et que le nom de la class soit NomDeDossier_NomDeFichier. En gros, il faut mettre devant le nom de la class toute l’arborescense du fichier jusqu’au dossier models. Enfin il y a une convention qui veut qu’on commence tous les nom de class par des majuscules, ce n’est pas obligatoire, mais en général cela permet de s’y retrouver plus facilement.

Un petit exemple pour comprendre comment instanciser un nouvel objet, et l’utiliser :

Fichier directement dans le dossier models:

class Test1 {

    private $nom;

    public function __construct($nom){
        $this->setNom($nom);
    }

    /**
     * @param $nom the $nom to set
     */
    public function setNom($nom) {
        $this->nom = $nom;
    }

    /**
     * @return the $nom
     */
    public function getNom() {
        return $this->nom;
    }
}

Fichier dans le dossier "dossier1" qui est fans le dossier models:

class dossier1_Test2 {

    private $nom;

    public function __construct($nom){
        $this->setNom($nom);
    }

    /**
     * @param $nom the $nom to set
     */
    public function setNom($nom) {
        $this->nom = $nom;
    }

    /**
     * @return the $nom
     */
    public function getNom() {
        return $this->nom;
    }
}

FactureController

/**
 * FactureController
 *
 * @author
 * @version
 */

require_once 'Zend/Controller/Action.php';

class FactureController extends Zend_Controller_Action {
    /**
     * The default action - show the home page
     */
    public function indexAction() {
        // TODO Auto-generated FactureController::indexAction()
        default action
    }

    public function ajouterAction(){
        $obj1 = new Test1('http://blog.lyrixx.info');
        $this->view->obj1 = $obj1;
        $obj2 = new dossier1_Test2('http://www.lyrixx.info');
        $this->view->obj2 = $obj2->getNom();
    }

    public function editerAction(){

    }

    public function supprimerAction(){

    }
}

vue:

/**
 * Default home page view
 *
 * @author
 * @version
 */

$this->headTitle('Ajouter une facure');
$this->placeholder('title')->set('Ajouter une facture');

echo $this->obj1->getNom();
echo '<br />';
echo $this->obj2;

On voit bien qu’on peut passer a la vue toute sorte d’objet : un objet, ou le résultat d’une de ses méthodes.

La suite : on avance dans le projet le bootstrap, la connection a la base de donnée.

Zend : Comment faire une vue ?

2009-06-26T00:00:00+02:00

Et bien on continue sur notre lancé avec les vues ou View dans le Zend Framework. Après les controller, maintenant les vues. La vue c’est la partie qui va s’occuper d’afficher vos résultats, vos variables, votre code html. Donc pour re-résumer les design pattern MVC :

Le controller est appelé et exécuté
Le controller crée et exécute des models (des objets)
le controller passe à la vue les variables dont la vue a besoin
la vue met en page ces variables et les donne au layout

Il faut savoir que par défaut il faut respecter une certaine syntaxe pour les nom de controller et de vue. Si notre controller s’appelle facture, il faudra que dans le dossier script, il y est un dossier facture. Puis si notre action s’appelle ajouter, il faudra que dans le dossier script/facture, il y est un fichier ajouter.phtml. Dans ce cas la, l’application exécutera la vues ajouter.phtml dans le dossier facture quand l’action ajouter du controller facture s’exécutera.

Tips : Comment faire une vues avec Zend Studio 7:

Enfin dans la vue, on aura pas besoin de mettre tout le code html de la page. Le layout le fait deja. Donc on a juste besoin de mettre le code html spécifique a cet action (l’action de ce controller).

Comment on fait pour récupérer nos variable du controller dans la vue?

et bien c’est vraiment pas compliqué : dans le controller il suffit de faire :

/**
 * FactureController
 *
 * @author
 * @version
 */

class FactureController extends Zend_Controller_Action {
    /**
     * The default action - show the home page
     */
    public function indexAction() {
        // TODO Auto-generated FactureController::indexAction()
        default action
    }

    public function ajouterAction(){
        $this->view->VariableString = "une varible";
        $this->view->VariableInt = 10;
        $this->view->VariableArray =
        array("n1"=>"a","n2"=>"b");
    }

    public function editerAction(){

    }

    public function supprimerAction(){

    }
}

Donc on passe une variable du controller a la vue grâce a la syntaxe suivante :

$this->view->Un_Nom_De_Varible

Ensuite on récupère les variables dans la vue grave à la syntaxe suivante :

$this->Un_Nom_De_Varible

Ex:

/**
 * Default home page view
 *
 * @author
 * @version
 */

$this->headTitle('Ajouter une facure');
$this->placeholder('title')->set('Ajouter une facture');

echo $this->VariableString;
echo '<br />';
echo $this->VariableInt;
echo '<br />';
echo print_r($this->VariableArray,true);

Voila. Il faut aussi savoir que les vues et les layouts sont étroitements liés. Qu’on peut faire passer des variables et toutes sortes de choses entre la vue et le layout.C’est le cas des placeholders que l’on peut voir au début du fichier ajouter.phtml

Et il faut aussi savoir qu’on peut changer dans le controller la vue qu’on veut appelé. C’est très pratique lorsqu’on a plein d’actions, mais qu’on a pas besoin de vues différentes a chaque action.

La suite : Comment utiliser un model avec Zend framework

Zend : Qu'est ce qu'un controller ?

2009-06-19T00:00:00+02:00

Comment utiliser les controllers dans Zend ?

En fait, le controller du Zend Framework c’est l’outil qui va complètement contrôler l’application, c’est a dire que c’est lui qui va s’occuper de lancer les calculs de récupérer les résultats et de les envoyer à la vue.

Donc par exemple si mon application est a l’adresse suivante : http://www.lyrixx.info/ et que je vais à l’adresse suivante : http://www.lyrixx.info/controller/action/ j’exécuterais le code du controller « controller » et plus précissement la méthode (on dit Action) « action« . Par défaut si on ne précisse pas de controller, ni d’action c’est le controller index et l’action index qui sera appelé. Donc l’adresse http://www.lyrixx.info/ est équivalente a http://www.lyrixx.info/index/ et est aussi équivalente à http://www.lyrixx.info/index/index/. Par exemple le controller par default ressemble a ca :

<?php

/**
 * IndexController - The default controller class
 *
 * @author
 * @version
 */

class IndexController extends Zend_Controller_Action
{
    /**
     * The default action - show the home page
     */
    public function indexAction()
    {
    // TODO Auto-generated IndexController::indexAction() action
    }
}

De plus les controllers doivent respecter une certaines terminologies :

Ils commencent par une majuscule
Finissent par « Controller.php«

De même pour les actions :

Elles commencent par une minuscules
Finissent par « Action«

Donc maintenant il va falloir définir les controllers. La c’est un peu une question de gout. C’est a travers les controllers qu’on va definir les urls de notre application (bien qu’il soit quand meme possible de les changer). Il faut qu’il y ai un bon equilibre entre le nombre de controller et le nombre d’action dans chaque controller.

Donc notre cas on a environ 5 types pages :

Ajouter / Editer / Supprimer une facture
Ajouter / Editer / Supprimer un utilisateur
Voir la liste des Facture
Calculer les sommes dues
Voir les statistiques

On va donc faire 5 controllers :

Facture pour Ajouter / Editer / Supprimer une facture
User pour Ajouter / Editer / Supprimer un utilisateur
Factures pour Voir la liste des Facture
Calcul pour Calculer les sommes dues
Stats pour Voir les statistiques

Et dans chaque controller on aura différente action. Par exemple pour le controller facture on aura comme action :

ajouter
editer
supprimer

** Truc et Astuces**

on peut ajouter facilement un controller dans zend studio (que je vous recommende fortement). Il suffit de faire CTRL+N puis de choisir Zend Controller :

Voila a quoi ressemble notre controller facture

Biensur, pour l’instant les actions sont vides. Il va falloir les « remplir » de code, mais on verra ca par la suite ! Maintenant que notre premier controller est fait, on peut essayé d’aller dessus. Mais il y a une exception qui est lancé. C’est normale, c’est qu’il n’y a pas encore de vue associé a ce controller. Il faut pour ça créer une vue.

On peut noter l’url pour acceder a cette action : …/facture/ajouter/

Voila maintenant on a plus qu’a faire une vue pour ce controller.

Zend : Comment utiliser un layout ?

2009-06-19T00:00:00+02:00

Comment utiliser un seul layout dans le Zend Framework ?

On va continuer d’utiliser la base qu’on avait sur la gestion de compte en collocation. On va donc reprendre le code de ce script et l’adapté a Zend. Dans le script de base, on avait deux fichiers : un header (header.php) et un footer (footer.php). On va donc pouvoir coller le code ou il faut dans le fichier main.phtml.

De base ce fichier ressemble a ca :

<?php

/**
 * Default Layout
 *
 * @author
 * @version
 */

echo '<?xml version="1.0" encoding="UTF-8" ?>';
echo $this->doctype()
?>

<html>

    <head>
        <meta http-equiv="Content-Type" content="text/html;
        charset=UTF-8" />
        <link rel="stylesheet" type="text/css" href="<?php echo
        $this->baseUrl();?>/styles/design.css" />
        <?php
        echo $this->headTitle();
        echo $this->headScript();
        echo $this->headStyle();
        ?>
    </head>

    <body>
        <h1><?php echo $this->placeholder('title')
        ?></h1>
        <?php echo $this->layout()->content ?>

        <br />
        <br />
    </body>

</html>

On va donc rajouter le header entre la balise body et la balise h1 et le footer juste avant la fin de body, en prenant soin d’enlever les balises en double. Cependant, on ne prend que le code de la partie après la balise body, zend s’occupant du reste. De plus on voit qu’il y a du code php dans le header, on n’en a pas encore besoin, on ne le copie pas encore. on obtient alors ce fichier :

<?php

/**
 * Default Layout
 *
 * @author
 * @version
 */

$temps_debut = microtime(true);
echo '<?xml version="1.0" encoding="UTF-8" ?>';
echo $this->doctype()
?>

<html>

    <head>
        <meta http-equiv="Content-Type" content="text/html;
        charset=UTF-8" />
        <link rel="stylesheet" type="text/css" href="<?php echo
        $this->baseUrl();?>/styles/design.css" />
        <?php
        echo $this->headTitle();
        echo $this->headScript();
        echo $this->headStyle();
        ?>
    </head>

    <body>
        <div id="header">
            <h1><a href="#">Gestion de
            compte</a></h1>
            <ul id="nav">
                <li><a href="index.php">Accueil</a></li>
                <li><a href="add_facture.php">Ajouter une facture</a></li>
                <li><a href="list_facture.php">Listes des factures</a></li>
                <li><a href="calcul.php">Calculer</a></li>
                <li><a href="user.php">Utilisateurs</a></li>
                <li><a href="stats.php">Stats</a></li>
            </ul>
        </div>

        <div id="container">
            <div id="content">
            <h1><?php echo $this->placeholder('title')
            ?></h1>
            <?php echo $this->layout()->content ?>
            </div>
        </div>

        <div id="footer">
            <p class="validate"><a href="http://validator.w3.org/check?uri=referer">XHTML</a>
            |
            <a href="http://jigsaw.w3.org/css-validator/">CSS</a>
            | <a href="#content">Top</a></p>
            <p><a href="www.lyrixx.info">© Pineau Gr&eacute;goire</a></p>
            <p>Temps de chargement : <?php $temps_fin = microtime(true); echo round($temps_fin - $temps_debut, 3);?> secondes | Nombre de requ&egrave;tes sql : <?php echo $nb_req?>
            </p>
        </div>

        <br />
        <br />
    </body>

</html>

Voila on a notre layout tout prêt. Cependant les liens ne fonctionnent pas encore. C’est normale, il n’y a pas encore de controller qui va s’occuper de gerer tout ca.

Architecture de Zend Framework en MCV

2009-06-17T00:00:00+02:00

Vous êtes nouveaux sur le Zend Framework, et vous êtes un peu perdu avec l’architecture MCV de ce framework. Pas de panique, je vous explique tout ! Deja, c’est quoi le MVC :

Le Modèle-Vue-Contrôleur (en abrégé MVC, de l’anglais Model-View-Controller) est une architecture et une méthode de conception qui organise l’interface homme-machine (IHM) d’une application logicielle. Ce paradigme divise l’IHM en un modèle (modèle de données), une vue (présentation, interface utilisateur) et un contrôleur (logique de contrôle, gestion des événements, synchronisation), chacun ayant un rôle précis dans l’interface.

D’après Wikipedia

Zend - Architecture

Voila, l’architecture typique d’une application Zend. Donc on retrouve tout en haut de l’achitecture, le dossier du projet : Budget.

Budget
- Application : contient toute l’application, en générale ce dossier ce situe a un endroit de votre serveur qui n’est pas accessible depuis l’extérieur (comme dans les CGI-BIN)
  - default : c’est le nom d’une application, en général on n’en a qu’une, mais sur de grosse architecture, on peut en avoir plusieurs.
    - controllers : ce sont les controlleurs (le C de MVC). ce sont eux qui vont creer des models pour excecuter des actions, des taches ou des opérations, ils founissent ensuite le ou les résultats à la vue.
    - helpers : ce sont des bouts de code utilisable dans tous les controllers
    - layouts : c’est le template de votre site
    - models : ce sont les models de votre application. Ce sont des class php qui vont faire le « gros » du travail
    - view : ce sont le vues de votre applications. On y retrouve :
      - filters : des filtres
      - helpers : des bouts de code commun que l’on peu aussi utiliser dans les layouts
      - scripts : les vrais vues. Ici il faut respecter une structure precise, en accord avec les controllers, mais on y reviendra
  - bootstrap.php et initializer.php sont les fichiers de chargement de l’application. c’est dans l’initializer qu’on fait les connections a la base de donnée par exemple.
- library : ici on a toutes les class dont zend a besoin pour fonctionner, et on a aussi toutes les autres class disponible (voir la doc …)
- public : c’est le dossier public qui est accessible depuis l’extérieur : on y retrouve toutes les feuilles de style, les fichiers javascripts, les images …
- test : ce dossier contient toutes les class qui servent a faire des tests unitaire.

On passe a la suite : Comment ajouter une feuille de style CSS et un fichier Javascript avec Zend Framework

Css, JavaScript et Zend Framework

2009-06-17T00:00:00+02:00

Comment lier une feuille de style CSS ou un fichier javascript proprement dans une application utilisant le Framework Zend ?

Etant donnée qu’on est dans un contexte model vue controller, et que le dossier public (qui contient les fichier css et js) est à un endroit totalement inconnu du reste de l’application (en MVC) on va devoir utiliser des helper. Ce sont des scripts php qui peuvent être utilisé a plusieurs endroit. Dans notre cas, on utilisera le helper dans le layout, qui definit notre page principale. C’est un peu le template du site.

On va creer un View Helper dans le dossier application/default/views/helpers :

class Zend_View_Helper_BaseUrl
{
    function baseUrl()
    {
        $fc = Zend_Controller_Front::getInstance();

        return $fc->getBaseUrl();
    }
}

Grâce a ce Helper, on pourra avoir la base de l’url de notre application. Donc maintenant il ne reste plus qu’a s’en servir dans le layout principale. On va donc copier notre fichier css dans le répertoire ./public/styles/:

*{outline:none;margin:0;padding:0;}
html{border:15px solid #f6f6f6;border-left:30px solid #f6f6f6;border-right:30px  solid #f6f6f6;}
body{background:#fff;font:16px/1.95em "Lucida Grande","Lucida Unicode",geneva,verdana,sans-serif;color:#666;padding-top:20px;border:3px solid #eee;margin:0;}
#header{width:100%;margin:0 auto;padding:20px 0;}
#header .right{float:right;}
#header h1{font:290% Times New Roman;letter-spacing:-2px;margin-bottom:5px;margin-left:35px;}
#header h1 a{color:#000;text-decoration:none;}
#header h1 a span{color:#ccc;}
#header h1 a:hover span{color:#A3E800;}
#header h3{font:80% Verdana;color:#999;display:inline;margin-left:35px;}
ul#nav{background:#8EDF53;font-size:80%;border-top:3px solid #6CCC26;border-bottom:3px solid #6CCC26;font-weight:700;margin:45px 0 0;padding:10px;}
ul#nav li{display:inline;list-style:none;margin-right:10px;}
ul#nav li a{color:#fff;text-decoration:none;padding:10px 14px;}
ul#nav li a:hover{background:#7EDB39;color:#fff;}
ul#nav li a.active{background:#fff;color:#333;border-right:2px solid #6CCC26;border-bottom:2px solid #6CCC26;}
#footer{margin-top:50px;clear:both;border-top:2px solid #eee;font:80% Verdana;line-height:25px;padding:20px 50px;}
#footer a{color:#999;}
#footer .validate{float:right;}
#container{width:95%;margin:0 auto;}
#content{width:100%;margin-bottom:50px;}
#content ul{margin:15px 0 15px 25px;}
#content ul li{border-bottom:1px solid #eee;color:#444;padding:10px;}
#content img{background:#fff;padding:1px;border:0px;}
#content h3{margin:20px 0;}
#content p{line-height:30px;word-spacing:2px;margin:20px 0;}
#content p a{color:#222;text-decoration:none;border-bottom:1px solid #ccc;}
#content p a:hover{border-bottom:1px solid #aaa;}
#content h2{font:190% Times;margin-top:45px;}
#content h2 a{color:#333;text-decoration:none;}
blockquote{background:#f6f6f6;border:1px solid #eee;font:100% Georgia;padding:0 10px;}
table{width:100%;border:1px solid #eee;padding:10px;}
th{color:#6CCC26;border-bottom:1px solid #eee;padding:5px;}
td{text-align:center;background:#fafafa;padding:5px;}
.formulaire{width:500px;margin-left:auto;margin-right:auto;border:solid 1px
#c8c8c8;background-color:#fafafa;padding:10px 10px 0;}
.formulaire fieldset{border:solid 1px #dcdcdc;margin:0 0 20px;padding:20px 0 0 !important;}
.formulaire fieldset legend{color:#505050;font-weight:700;font-size:130%;margin:0 0 0 5px !important;padding:0 2px;}
.formulaire label.left{float:left;width:200px;font-size:110%;margin:0 0 0 10px;padding:2px;}
.formulaire select.combo{width:175px;border:solid 1px #c8c8c8;font-family:verdana,arial,sans-serif;font-size:110%;padding:2px;}
.formulaire input.field{width:275px;border:solid 1px #c8c8c8;font-family:verdana,arial,sans-serif;font-size:110%;padding:2px;}
.formulaire textarea{width:275px;height:250px;border:solid 1px #c8c8c8;font-family:verdana,arial,sans-serif;font-size:110%;padding:2px;}
.formulaire input.button{float:right;width:9em;margin-right:20px;background:#e6e6e6;border:solid 1px #969696;text-align:center;font-family:verdana,arial,sans-serif;color:#969696;font-size:110%;padding:1px !important;}
.formulaire input.button:hover{cursor:pointer;border:solid 1px #505050;background:#dcdcdc;color:#505050;}
.info_msg_class{border:1px solid #000;background:#fafafa;text-align:center;padding:10px;}
.button1 a{margin:0 3px;padding:2px 5px;text-decoration:none;background:#eee;border:solid 1px #aaa;color:#aaa;text-align:center;}
.button1 a:hover{cursor:pointer;border:solid 1px #555;background:#dcdcdc;color:#555;}
input.calendar {width:150px;border:solid 1px #c8c8c8;font-family:verdana,arial,sans-serif;font-size:110%;padding:2px; float: left;}
button.calendar {float: left;width: 24px;height: 24px;border: 0;margin-left: 10px;cursor: pointer;background: url('../img/calendar.png');}
button.calendar:hover , button.calendar.active {background-position: left bottom;}
div.calendar{background:#eee;}
.fact_option{width:60px;}
.user_option{width:40px;}
.nowrap{white-space:nowrap}
.barrer > td{text-decoration:line-through;}
.change_payed {border-bottom:2px dotted #6CCC26}
.change_payed2 {white-space:nowrap;}
.calcul{margin:1px 5px;padding:2px 5px;background:#e6e6e6;border:outset 1px #969696;color:#969696;}
.calcul:hover{cursor:pointer;border:inset 1px #505050;background:#dcdcdc;color:#505050;}

Puis maintenant il faut editer le fichier application/default/layouts/main.phtml qui est le template par default et on ajoute la notre** feuille de style** :

/**
 * Default Layout
 *
 * @author
 * @version
 */

echo '<?xml version="1.0" encoding="UTF-8" ?>';
echo $this->doctype()
?>

<html>

    <head>
        <meta http-equiv="Content-Type" content="text/html;
        charset=UTF-8" />
        <link rel="stylesheet" type="text/css" href="<?php echo
        $this->baseUrl();?>/styles/design.css" />
        <?php
        echo $this->headTitle();
        echo $this->headScript();
        echo $this->headStyle();
        ?>
    </head>

    <body>
        <h1><?php echo $this->placeholder('title')
        ?></h1>
        <?php echo $this->layout()->content ?>

        <br />
        <br />
    </body>

</html>

Voila maintenant il suffit de faire la meme chose pour les fichiers JavaScipts On peut donc passer a la suite avec : Comment mettre en place un layout ou template avec Zend Framework