Définition du modèle de données

Pour commencer, nous allons définir notre modèle de données. Sous Symfony, bien plus qu'en développement PHP standard (comprendre : sans framework), il est très important de bien concevoir au début sa base de données. Passez donc un peu plus de temps que d'habitude pour bien réfléchir à toutes les relations entre vos différentes tables. Toute la partie rébarbative sera réalisée toute seule par ce merveilleux framework. ;)

Pour notre application de tâches, celle-ci sera relativement basique. Nous aurons donc deux tables : une table member et une table task. Avec un bout de papier et un crayon (ou, dans mon cas, avec Paint.Net), voici le modèle que nous pouvons générer.

On remarquera au passage mes talents extraordinaires de graphiste. Je me suis trompé de voie visiblement... :p

Utilisation de Doctrine

On peut donc le traduire en YAML. Il s'agit d'un langage (de type clefs/valeurs) permettant de décrire sous une forme humainement compréhensible un modèle de données. Symfony utilisera les fichiers YAML pour construire la base de données et éventuellement la remplir, comme nous allons le voir dans peu de temps.

Petite remarque importante avant de commencer : ne mettez jamais de tabulations dans vos fichiers YAML. Sinon, ceux-ci ne seront pas valides. ;)

On traduit donc notre schéma en langage YAML, en éditant le fichier /config/doctrine/schema.yml.

member:
    actAs: { Timestampable: ~ }
    columns:
        firstName: { type: string(255), notnull: true }
        lastName: { type: string(255), notnull: true }
        email: { type: string(255), notnull: true, unique: true }
        password: { type: string(255), notnull: true }

task:
    column:
        member_id: { type: integer, notnull: true }
        task: { type: string(255), notnull: true }
        expires_at: { type: timestamp }
    relations:
        member: { onDelete: CASCADE, local: member_id, foreign: id }

La première instruction de chaque bloc sera le nom de la table correspondante. Par convention, on nommera ces tables au singulier.

Dans la table member, on remarque la première ligne, avec actAs. Il s'agit ici d'un comportement particulier. Ainsi, la table member implémentera le comportement Timestampable, qui ajoutera (et gérera) automatiquement les champs created_at et updated_at. Cela explique notamment pourquoi on ne les retrouve pas dans la description de chacune des colonnes, situées sous le label columns.

Dans celui-ci, on retrouve le type des colonnes (ici, que des chaînes de caractères), ainsi que l'interdiction pour celles-ci d'être nulles. C'est important, dans la mesure où Symfony s'en servira lors de la génération automatique des formulaires pour la validation : si l'utilisateur oublie de remplir un champ marqué notnull (donc obligatoire), alors un message d'erreur apparaîtra. Enfin, on spécifie également l'unicité de l'adresse e-mail (afin d'éviter qu'un même membre se réinscrive par mégarde) grâce à l'option unique.

On remarque également que nous n'avons pas mis l'id dans les descriptions des colonnes. Celui-ci sera automatiquement inséré.

Enfin, l'attribut relations permet de mettre en place la contrainte de clef étrangère (la flèche bleue de notre schéma). On lie donc la table task à la table member, dont la clef étrangère member_id (clef local) référencie la clef primaire id (clef foreign). Enfin, si on supprime un membre, on supprime également toutes les tâches qui lui sont associés, ce qui est indiqué par onDelete: CASCADE.

Nous pouvons donc à présent faire appel à Doctrine. Doctrine est un ORM (Object Relational Mapping). Un ORM permet de manipuler des bases de données grâce à des objets. Ainsi, dans ce cas, Doctrine créera des classes PHP pour interagir avec nos tables MySQL.

Pour ce faire, commençons par configurer les accès à notre base de données :

php symfony configure:database "mysql:host=localhost;dbname=toudoo" root root

L'ordre des arguments de configure:database est la chaîne de connexion à la base de données (ici, on se sert de MySQL pour se connecter en local à la base toudoo), le nom d'utilisateur et le mot de passe. Si tout se passe bien, vous devriez retrouver ces réglages dans le fichier /config/databases.yml :

all:
  doctrine:
    class: sfDoctrineDatabase
    param:
      dsn: 'mysql:host=localhost;dbname=toudoo'
      username: root
      password: root

Une fois ceci configuré, nous pouvons demander à Doctrine de créer les tables dans notre base ainsi que les fichiers modèles qui nous permettront d'interagir facilement avec la base. Doctrine créera également les formulaires et les filtres de formulaires, sur lesquels nous reviendrons plus tard.

php symfony doctrine:build --all --no-confirmation

Si tout se passe bien, vous devriez voir une sortie semblable à :

>> doctrine  Dropping "doctrine" database
>> doctrine  Creating "dev" environment "doctrine" database
>> doctrine  generating model classes
>> file+     C:\Users\Jonathan Petitcolas\Ap...\Temp/doctrine_schema_54820.yml
>> tokens    D:/Sites/toudoo/lib/model/doctrine/base/Basemember.class.php
>> tokens    D:/Sites/toudoo/lib/model/doctrine/base/Basemembers.class.php
>> tokens    D:/Sites/toudoo/lib/model/doctrine/base/Basetask.class.php
>> tokens    D:/Sites/toudoo/lib/model/doctrine/base/Basetasks.class.php
>> autoload  Resetting application autoloaders
>> file-     D:/Sites/toudoo/cache/frontend/.../config/config_autoload.yml.php
>> doctrine  generating form classes
>> tokens    D:/Sites/toudoo/lib/form/BaseForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/base/BasememberForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/base/BasemembersForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/base/BasetaskForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/base/BasetasksForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/BaseFormDoctrine.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/memberForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/membersForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/taskForm.class.php
>> tokens    D:/Sites/toudoo/lib/form/doctrine/tasksForm.class.php
>> autoload  Resetting application autoloaders
>> file-     D:/Sites/toudoo/cache/frontend/.../config/config_autoload.yml.php
>> doctrine  generating filter form classes
>> tokens    D:/Sites/toudoo/lib/filter/doct.../BasememberFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doct...BasemembersFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doct...se/BasetaskFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doct...e/BasetasksFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doct...aseFormFilterDoctrine.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doctrine/memberFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doctrine/membersFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doctrine/taskFormFilter.class.php
>> tokens    D:/Sites/toudoo/lib/filter/doctrine/tasksFormFilter.class.php
>> autoload  Resetting application autoloaders
>> file-     D:/Sites/toudoo/cache/frontend/.../config/config_autoload.yml.php
>> doctrine  generating sql for models
>> doctrine  Generated SQL successfully for models
>> doctrine  creating tables
>> doctrine  created tables successfully

On peut ainsi voir que Doctrine crée les modèles dans le dossier /lib/model/doctrine, les formulaires dans /lib/form/doctrine, les filtres de formulaires dans /lib/filter/doctrine/ et les instructions SQL optimisées pour le serveur sous-jacent dans /data/sql/.

Tant que nous y sommes, nous pouvons jeter un oeil dans notre base de données, afin de s'assurer que tout y a bien été créé.

Dans le but d'avoir un aperçu rapide du fonctionnement de notre application, nous allons déjà peupler la base de données de quelques enregistrements. On utilisera encore un fichier YAML. Les données à insérer sont dans le dossier /data/fixtures/.

On crée un premier fichier pour les membres, members.yml.

member:
    Jonathan:
        firstName: Jonathan
        lastName: Petitcolas
        email: contact@jonathan-petitcolas.com
        password: password
    Tim:
        firstName: Tim
        lastName: Speek
        email: tim.speek@skype.com
        password: voipIsgr3aT

Puis, dans le fichier tasks.yml :

task:
    world:
        member: Jonathan
        task: Conquer the World!
    wealth:
        member: Jonathan
        task: Become rich and famous. Arf... I've forgotten I was already! :p
    boobs:
        member: Tim
        task: Put words "boobs", "ass", "sex" and "pussy" to improve SEO.

On remarque que chaque enregistrement dispose d'une étiquette. Celle-ci, obligatoire (pour bien différencier chaque enregistrement), permet également de simplifier l'utilisation des clefs étrangères. Ainsi, la tâche boobs est associé à Tim.

A présent, remplissons notre base de données avec ces enregistrements grâce à la commande suivante :

php symfony doctrine:data-load

On pourra s'assurer du bon fonctionnement de celle-ci avec le retour suivant :

>> doctrine  Loading data fixtures from "D:\Sites\toudoo\data/fixtures"
>> doctrine  Data was successfully loaded

Pour les plus maniaques (dont je fais partie... :$), vous pouvez supprimer le fichier fixtures.yml, qui n'est là qu'à titre d'exemple et n'a donc aucune utilité.

Si on jette un coup d'oeil sur nos tables, on s'aperçoit qu'elles sont à dorénavant remplies.

Maintenant que tout cela est fait, créons les modules correspondant à nos deux entités.

Définition d'un module

Qu'est-ce qu'un module ? Afin de mieux comprendre, reprenons depuis le début, du plus général au plus précis.

Tout d'abord, nous avons notre projet. Celui-ci est définit (pour faire simple) par une conception particulière, un but final général. Par exemple, un gestionnaire de tâches.

Puis, nous avons les applications. Les applications ne partagent entre elles que les modèles de données. Elles s'appuieront donc toutes sur les mêmes données, mais c'est tout. Rien d'autre ne leur sera commun. Ainsi, dans notre cas, nous aurons la partie frontend (qui sera visible par les utilisateurs) et la partie backend, qui elle ne sera visible que par les administrateurs. Mais nous verrons cela bien plus tard. ;)

Au niveau en-dessous des applications, on trouve les modules. Ceux-ci représentent une partie majeure de l'application. On découpe en fait en morceaux l'application, ces morceaux étant appelés modules. Ainsi, dans notre cas, on aura un module members pour gérer nos utilisateurs et un module tasks pour gérer les tâches.

Enfin, si nous voulons vraiment peaufiner, nous avons les actions. Les actions sont simplement les briques unitaires de notre module. On peut citer pour l'exemple les actions par défaut d'un module : l'ajout, la suppression, le listing ou encore l'édition.

Si ce n'est pas très clair, pas de panique. Cela viendra petit à petit avec votre utilisation de Symfony. :)

Création du module member

Nous allons commencer par le commencement, à savoir par la création du module des membres. Retournez à votre ligne de commande, et exécutez l'instruction suivante :

php symfony doctrine:generate-module --with-show --non-verbose-templates frontend members member

On génère un module comme vous pourrez le constater. Mais également quelques arguments, dont voici la signification :

• --with-show : donne une méthode de visualisation de l'entité,
• --non-verbose-templates : permet une manipulation plus orientée objet des formulaires... Nous y reviendrons plus tard.
• frontend : application dans laquelle le module devra se trouver,
• members : nom du module,
• member : nom de la table associée.

Nous avons une sortie à laquelle nous commençons à être habitués :

>> dir+      D:\Sites\toudoo\apps\frontend\modules/members\actions
>> file+     D:\Sites\toudoo\apps\frontend\m...mbers\actions/actions.class.php
>> dir+      D:\Sites\toudoo\apps\frontend\modules/members\templates
>> file+     D:\Sites\toudoo\apps\frontend\m...mbers\templates/editSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...bers\templates/indexSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...embers\templates/newSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...mbers\templates/showSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...les/members\templates/_form.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/actions/actions.class.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/templates/editSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...bers/templates/indexSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...embers/templates/newSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/templates/showSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...les/members/templates/_form.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/actions/actions.class.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/templates/editSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...bers/templates/indexSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...embers/templates/newSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...mbers/templates/showSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...les/members/templates/_form.php
>> file+     D:\Sites\toudoo\test\functional\frontend\membersActionsTest.php
>> tokens    D:\Sites\toudoo\test\functional\frontend\membersActionsTest.php
>> file-     D:/Sites/toudoo/cache/tmp/87952...autoMembers/templates/_form.php
>> file-     D:/Sites/toudoo/cache/tmp/87952...mbers/templates/showSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/87952...embers/templates/newSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/87952...bers/templates/indexSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/87952...mbers/templates/editSuccess.php
>> dir-      D:/Sites/toudoo/cache/tmp/87952...eda40aa36/autoMembers/templates
>> file-     D:/Sites/toudoo/cache/tmp/87952...mbers/actions/actions.class.php
>> dir-      D:/Sites/toudoo/cache/tmp/87952...caeda40aa36/autoMembers/actions
>> dir-      D:/Sites/toudoo/cache/tmp/87952...6c250993caeda40aa36/autoMembers

Essentiellement, cette ligne de commande a généré différents templates et actions dans notre application frontend, dans le dossier de modules members.

Nous avons fini pour la mise en place du module de membres. Vous pouvez à présent vous connecter à l'adresse du module, en environnement de développement (celui-ci n'est en effet pas encore accessible en production) : http://toudoo/frontend_dev.php/members.

On remarque alors que plusieurs pages ont été créées, permettant la visualisation, l'édition, l'ajout et la suppression de tous les enregistrements des membres. Magique, non ? :)

Comme on peut le constater, il n'y a pas de CSS. C'est tout à fait normal : nous verrons comment personnaliser l'affichage de notre site dans le billet suivant.

Quelque chose peut choquer : la saisie manuelle des champs created_at et updated_at. Rassurez-vous, nous verrons, lors de l'étude des formulaires Symfony, comment faire disparaître ceux-ci.

Après s'être amusé avec les membres, nous allons créer le module des tâches.

php symfony doctrine:generate-module --with-show --non-verbose-templates frontend tasks task

Ce qui donne, encore et toujours :

>> dir+      D:\Sites\toudoo\apps\frontend\modules/tasks\actions
>> file+     D:\Sites\toudoo\apps\frontend\m...tasks\actions/actions.class.php
>> dir+      D:\Sites\toudoo\apps\frontend\modules/tasks\templates
>> file+     D:\Sites\toudoo\apps\frontend\m...tasks\templates/editSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...asks\templates/indexSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m.../tasks\templates/newSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\m...tasks\templates/showSuccess.php
>> file+     D:\Sites\toudoo\apps\frontend\modules/tasks\templates/_form.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/actions/actions.class.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/templates/editSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...asks/templates/indexSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m.../tasks/templates/newSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/templates/showSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/modules/tasks/templates/_form.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/actions/actions.class.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/templates/editSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...asks/templates/indexSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m.../tasks/templates/newSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/m...tasks/templates/showSuccess.php
>> tokens    D:/Sites/toudoo/apps/frontend/modules/tasks/templates/_form.php
>> file+     D:\Sites\toudoo\test\functional\frontend\tasksActionsTest.php
>> tokens    D:\Sites\toudoo\test\functional\frontend\tasksActionsTest.php
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...9/autoTasks/templates/_form.php
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...Tasks/templates/showSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...oTasks/templates/newSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...asks/templates/indexSuccess.php
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...Tasks/templates/editSuccess.php
>> dir-      D:/Sites/toudoo/cache/tmp/a1c6e...2410b844369/autoTasks/templates
>> file-     D:/Sites/toudoo/cache/tmp/a1c6e...Tasks/actions/actions.class.php
>> dir-      D:/Sites/toudoo/cache/tmp/a1c6e...e82410b844369/autoTasks/actions
>> dir-      D:/Sites/toudoo/cache/tmp/a1c6e...4bc2964fe82410b844369/autoTasks

Comme nous pouvons le voir, Symfony nous simplifie énormément la vie. Enfin, presque. Car, il y a un petit défaut avec les membres...

D'après ce formulaire, nous devrions connaître par coeur les identifiants de tous les membres. Imaginez si notre base contient plusieurs milliers de membres... Heureusement, il est possible de modifier ce comportement par défaut (la colonne member_id étant numérique) grâce à la méthode __toString() du modèle Member.

On modifie donc comme suit la classe modèle de notre membre, /lib/model/doctrine/member.class.php :

public function __toString()
{
	return $this->getFirstName().' '.$this->getLastName();
}

On récupère donc le prénom et le nom, grâce aux accesseurs de Symfony. Ce qui donnera donc, dans notre nouveau formulaire :

C'est sur cette magie que nous allons nous laisser sur ce deuxième tutorial. Au final, nous n'avons fait qu'appeler quelques commandes et écrire une ligne PHP, et nous avons une application particulièrement importante, qui aurait demandé quelques heures de développement sans un tel framework. Et je vous assure : ce n'est pas fini. :)

Dans le prochain article, nous verrons comment gérer l'aspect graphique de notre site, avec les CSS, les layouts et les slots.

Attention, ce n'est pas très simple à lire, étant rédigé en vieux français.

Tant plus je voy que vous blamez
Si noble discipline,
Plus à l'aimer vous enflammez
Ma volonté encline.
Car ce qui a moins de suivans
D'autant plus il est rare,
Et est la chose entre vivans
Dont on est plus avare.
Il n'est pas en nostre puissance
Qu'y soyez addonnez :
Car le ciel dès vostre naissance
Vous en a destournez :
Ou ayant persuasion
Que tant la peine en couste,
Est la meilleure occasion
Qui tant nous en desgouste.
Le Ciel orné de tels flambeaux
N'est-il point admirable ?
La notice de corps si beaux
N'est-elle désirable ?
Du céleste ouvrage l'obget
Si vray et régulier ?
N'est-il sur tout autre suget
Beau, noble et singulier ?
N'est-ce rien d'avoir peu prévoir
Par les cours ordinaires
L'Eclipse que doit recevoir
L'un des deux Luminaires ?
D'avoir seu par vrayes pratticques
Les aspectz calculer ?
Et congnoistre les Erraticques
Marcher ou reculler ?
Touteffois il n'est ja besoing
Que tant fort je la loue,
Veu que je n'ay vouloir ni soing
Que de ce l'on m'avoue ;
Car que chaut-il à qui l'honore
Qu'elle soit contennée ?
Science de cil qui l'ignore
Est toujours condannée,
Assez regarde l'indocte homme
Du Ciel rond la ceinture,
Mais il s'y congnoit ainsi comme
L'aveugle en la peinture.
Celuy qui a l'ame ravie
Par les cieux va et passe
Et souvent voit durant sa vie
D'en hault la terre basse.
Ceste science l'homme cueille
Alors qu'il imagine
La facture et grande merveille
De la ronde machine.
C'est celle par qui mieux s'apprenne
L'immense Déité,
Et qui des Athées reprenne
L'erreur et vanité.

Bref, malgré un apprentissage parfois difficile (car, oui, je l'avoue, certains aspects sont particulièrement abstraits...), la Mathématique fournit toujours une grande satisfaction aux esprits logiques. :)

function getUrlParameter(name) {

    var searchString = location.search.substring(1).split('&');

    for (var i = 0; i < searchString.length; i++) {

        var parameter = searchString[i].split('=');
        if(name == parameter[0])    return parameter[1];

    }

    return false;
}

Cette fonction récupère la chaîne de caractères location.search qui représente, pour l'appel à la page index.php?page=members&action=show, la chaîne ?page=members&action=show. Le substring permet de retirer le point d'interrogation et le split de couper la chaîne aux emplacements des esperluettes (le vrai nom de ce symbole &).

Puis, on parcourt le tableau obtenu à la recherche du paramètre $_GET dont le nom a été passé en argument de la fonction.

Rien de bien compliqué... Encore faut-il connaître la variable location.search. :)

Tout d'abord, on ajoute un nouveau dépôt, qui nous permettra de le récupérer facilement. Editons donc le fichier /etc/apt/sources.list :

# nano /etc/apt/sources.list

Et ajoutons à la fin le nouveau dépôt grâce aux deux lignes suivantes :

# PHP 5.3
deb http://php53.dotdeb.org lenny all
deb-src http://php53.dotdeb.org lenny all

Pour que ce dépôt soit pris en compte avec Aptitude, nous devons ajouter sa clef GPG, garante de son intégrité.

# gpg --keyserver keys.gnupg.net --recv-key 89DF5277
# gpg -a --export 89DF5277 | sudo apt-key add -

Enfin, mettons à jour Aptitude, et téléchargeons notre nouvelle version de PHP 5.3.

# apt-get update
# apt-get upgrade
# apt-get install libapache2-mod-php5 php5-cli

Et vous voilà à présent avec une installation pleinement opérationnelle de PHP 5.3. Pour vous en convaincre, un petit phpinfo :

<?php phpinfo(); ?>

Encore une victoire du développeur face au système ! :)

Voici le descriptif de l'offre (honteusement placée sur de nombreux sites ! :p) :

Présentation de la société

TL Conseil est une société qui intervient dans le conseil en stratégie, le lobbying et la communication d’influence. Elle a été créée 2003 par Thomas Legrain, diplômé de l’ESSEC et ancien du Boston Consulting Group.

Nos clients sont des grands groupes, des PME leaders de leur secteur, des institutionnels ou des collectivités locales. Actuellement, nous travaillons notamment pour le Conseil du Commerce de France, le Conseil Supérieur de l’Ordre des Experts-comptables, la Compagnie régionale des Commissaires aux Comptes de Paris, la Fédération des Centres de Gestion Agréés, Groupama ou encore la SEITA – Groupe Imperial Tobacco.

Poste :

Nous proposons un poste de développeur web spécialisé en PHP 5 objet pour des missions de développement tant pour la société TL Conseil que pour ses clients dans le domaine de la communication d’influence.

Ce poste nécessite de la rigueur dans la gestion de projets, une grande motivation, de l’autonomie et la capacité d’intervenir sur différents projets avec des contraintes de temps. Des compétences en gestion d’équipes sont également recommandées.

Les orientations techniques des futurs développements seront sous l’entière responsabilité du titulaire du poste.

Profil recherché :

• Programmation PHP 5 orientée objet
• Utilisation d’un framework propriétaire (documentation en cours de rédaction)
• Connaissance d’XHTML et CSS
• Utilisation de MooTools
• Administration Linux liée aux serveurs Web (Apache2 sous Debian)
• Veille technologique

En pratique :

Lieu de travail : 6 avenue Rachel – 75018 Paris – métro Place de Clichy, Blanche.
Disponibilité : dès que possible.
Rémunération : 36 k€ brut annuel + prime sur chiffre d’affaires réalisé

Contact :

Jonathan Petitcolas – 01.42.94.93.14 – jpetitcolas@tlconseil.com

Vous pouvez également laisser un commentaire sur cet article.

Dépêchez-vous, il n'y a qu'une seule place ! ;)

Le but de cette série de billets sera de vous faire partager mon expérience naissante sur ce framework PHP en créant une application de ToDo-List. Celle-ci comprendra un espace membres basique (afin que chacun ne voit que les tâches qui lui sont attribuées) et également quelques autres petites fonctionnalités.

[Note : ce tutoriel est réalisé sous Windows mais est facilement transposable sous Linux. Seule la partie de modification de la variable d'environnement Path n'a pas lieue d'être avec le pingouin.]

Installation de Symfony

Pour installer Symfony, rien de plus simple. Je suppose tout d'abord que le lecteur sait configurer un VirtualHost avec la solution qu'il utilise habituellement (étant sous Windows pour jouer à WoW essentiellement - je sais, c'est le mal ! - j'utilise UwAmp, que je trouve plus pratique que Wamp). Nous nommerons ce projet Toudoo par la suite.

Test de la configuration (1/2)

Tout d'abord, vérifions que les paramètres requis par Symfony sont bien configurés sur votre machine. Pour ce faire, il existe un script récupérable à l'adresse :

http://sf-to.org/1.4/check.php

Téléchargez-le, et placez-le dans votre DocumentRoot.

Nous allons à présent devoir l'exécuter en deux temps. Une première fois en ligne de commandes, et une seconde fois à travers votre navigateur. Pourquoi tester deux fois ? Car la configuration en CLI (ligne de commandes) n'est pas la même que celle pour les navigateurs. C'est d'ailleurs une source d'erreurs assez fréquente lorsque l'on commence à utiliser l'interface console.

Commençons par le plus facile : le test à travers le navigateur. Ouvrez donc ce fichier en vous servant du VirtualHost configuré précédemment.

********************************
*                              *
*  symfony requirements check  *
*                              *
********************************

php.ini used by PHP: C:\UwAmp\apache\php.ini

** Mandatory requirements **

  OK        PHP version is at least 5.2.4 (5.2.13)

** Optional checks **

  OK        PDO is installed
  OK        PDO has some drivers installed: mysql, sqlite, sqlite2
  OK        PHP-XML module is installed
  OK        XSL module is installed
  OK        The token_get_all() function is available
  OK        The mb_strlen() function is available
  OK        The iconv() function is available
  OK        The utf8_decode() is available
[[WARNING]] The posix_isatty() is available: FAILED
            *** Install and enable the php_posix extension (used to colorized the CLI output) ***
[[WARNING]] A PHP accelerator is installed: FAILED
            *** Install a PHP accelerator like APC (highly recommended) ***
  OK        php.ini has short_open_tag set to off
  OK        php.ini has magic_quotes_gpc set to off
  OK        php.ini has register_globals set to off
  OK        php.ini has session.auto_start set to off
  OK        PHP version is not 5.2.9

Comme nous pouvons le constater, nous avons deux avertissements. Ceux-ci ne sont pas dramatiques et n'empêchent en rien le bon fonctionnement du framework. L'absence de posix_isatty ne coloriera pas les retours en mode console (et n'est de toute façon pas disponible sous Windows), et l'accélérateur PHP n'a que peu d'importance en développement (mais s'avère vital pour gérer une bonne montée en charge en environnement de production). Nous ne nous attarderons donc pas dessus. On peut donc considérer que tout est opérationnel.

Modification de la variable d'environnement Path

Testons à présent en mode console. Tout d'abord, et afin d'éviter d'avoir à écrire de trop longues commandes (oui, le geek est fainéant à la base, ne l'oublions pas !), nous allons modifier la variable d'environnement Path qui contient les dossiers à partir desquels nous pouvons appeler directement un exécutable. Pour ce faire : Menu Démarrer > Clic-droit sur Ordinateur > Propriétés > Paramètres systèmes avancés > Variables d'environnement.

[troll]Vive la simplicité de Windows ![/troll]

Dans le fenêtre (enfin) ouverte, recherchez la variable Path, et ajoutez le dossier contenant le binaire php.exe. Sous UwAmp, on rajoutera à la fin de la liste de dossiers (séparés par des points virgules) le dossier C:\UwAmp\apache\php_5.3.2.

Démarrons donc une invite de commandes (touche Windows + R ; tapez cmd). Grâce à notre changement de variable d'environnement, nous pourrons appeler l'interpréteur PHP directement grâce à la ligne de commande :

php

Sans, il aurait fallu écrire :

C:\UwAmp\apache\php_5.3.2\php

Vous comprenez à présent pourquoi cette modification est importante ! :)

Test de la configuration (2/2)

Plaçons nous donc dans notre dossier et exécutons le même script (à savoir check_configuration.php). Bien entendu, il faudra changer le nom de dossier par le votre. ;)

D:
cd D:\Sites\toudoo\
php check_configuration.php

On obtient alors davantage d'avertissements (par défaut) :

********************************
*                              *
*  symfony requirements check  *
*                              *
********************************

php.ini used by PHP: WARNING: not using a php.ini file

** WARNING **
*  The PHP CLI can use a different php.ini file
*  than the one used with your web server.
*  (especially on the Windows platform)
*  If this is the case, please launch this
*  utility from your web server.
** WARNING **

** Mandatory requirements **

  OK        PHP version is at least 5.2.4 (5.3.2)

** Optional checks **

  OK        PDO is installed
[[WARNING]] PDO has some drivers installed: : FAILED
            *** Install PDO drivers (mandatory for Propel and Doctrine) ***
  OK        PHP-XML module is installed
[[WARNING]] XSL module is installed: FAILED
            *** Install and enable the XSL module (recommended for Propel) ***
  OK        The token_get_all() function is available
[[WARNING]] The mb_strlen() function is available: FAILED
            *** Install and enable the mbstring extension ***
  OK        The iconv() function is available
  OK        The utf8_decode() is available
[[WARNING]] The posix_isatty() is available: FAILED
            *** Install and enable the php_posix extension (used to colorized the CLI output) ***
[[WARNING]] A PHP accelerator is installed: FAILED
            *** Install a PHP accelerator like APC (highly recommended) ***
[[WARNING]] php.ini has short_open_tag set to off: FAILED
            *** Set it to off in php.ini ***
[[WARNING]] php.ini has magic_quotes_gpc set to off: FAILED
            *** Set it to off in php.ini ***
  OK        php.ini has register_globals set to off
  OK        php.ini has session.auto_start set to off
  OK        PHP version is not 5.2.9

On voit bien que le fichier de configuration utilisé n'est pas le même. La solution ? Utiliser le même. ;)

Pour ce faire, copiez le fichier C:\UwAmp\apache\php.ini dans C:\UwAmp\apache\php_5.3.2\php.ini. Si le fichier n'existe pas, créez le. Puis, redémarrez votre serveur Apache, et réessayez. Le test devrait à présent être concluant (malgré l'appartion de deux messages d'erreurs chez moi indiquant que les fichiers php_exif.dll et php_mbstring.dll sont manquants... ce qui n'a pas l'air d'influer sur la suite).

Une fois que la configuration est opérationnelle, on supprime le fichier check_configuration.php. Fichier avec un nom standard, il pourrait révéler certaines choses à un pirate potentiel. Jouons donc la carte de la sécurité. ;)

Déploiement du framework

Après tant de vérification et de configuration ô combien pas très passionante, nous pouvons enfin téléchargez Symfony. Nous prendrons la dernière version stable (ici, la 1.4) afin de profiter des dernières nouveautés du framework.

Décompressez-là dans un dossier (par convention) lib/vendor/ de votre DocumentRoot. Il est important de respecter toutes les conventions de nommage utilisées lors de l'utilisation d'un framework. Et encore plus pour Symfony, qui utilise tout un ensemble de scripts de génération automatique qui nous feront gagner un temps précieux.

Retournons donc en ligne de commande, et exécutons le script suivant :

php lib\vendor\data\bin\symfony generate:project toudoo

La sortie de ce script est assez impressionante. Mais rien de bien extraordinaire, si ce n'est la création de toute l'arborescence de dossiers du projet.

>> dir+      D:\Sites\toudoo\apps
>> dir+      D:\Sites\toudoo\cache
>> dir+      D:\Sites\toudoo\config
>> file+     D:\Sites\toudoo\config/ProjectConfiguration.class.php
>> file+     D:\Sites\toudoo\config/properties.ini
>> file+     D:\Sites\toudoo\config/rsync_exclude.txt
>> dir+      D:\Sites\toudoo\data
>> dir+      D:\Sites\toudoo\data/fixtures
>> file+     D:\Sites\toudoo\data/fixtures/fixtures.yml
>> dir+      D:\Sites\toudoo\lib/form
>> file+     D:\Sites\toudoo\lib/form/BaseForm.class.php
>> dir+      D:\Sites\toudoo\log
>> dir+      D:\Sites\toudoo\plugins
>> file+     D:\Sites\toudoo\symfony
>> dir+      D:\Sites\toudoo\test
>> dir+      D:\Sites\toudoo\test/bootstrap
>> file+     D:\Sites\toudoo\test/bootstrap/functional.php
>> file+     D:\Sites\toudoo\test/bootstrap/unit.php
>> dir+      D:\Sites\toudoo\test/functional
>> dir+      D:\Sites\toudoo\test/unit
>> dir+      D:\Sites\toudoo\web
>> file+     D:\Sites\toudoo\web/.htaccess
>> dir+      D:\Sites\toudoo\web/css
>> file+     D:\Sites\toudoo\web/css/main.css
>> dir+      D:\Sites\toudoo\web/images
>> dir+      D:\Sites\toudoo\web/js
>> file+     D:\Sites\toudoo\web/robots.txt
>> dir+      D:\Sites\toudoo\web/uploads
>> dir+      D:\Sites\toudoo\web/uploads/assets
>> tokens    D:/Sites/toudoo/config/ProjectConfiguration.class.php
>> tokens    D:/Sites/toudoo/config/properties.ini
>> tokens    D:/Sites/toudoo/config/rsync_exclude.txt
>> tokens    D:/Sites/toudoo/config/ProjectConfiguration.class.php
>> tokens    D:/Sites/toudoo/config/properties.ini
>> tokens    D:/Sites/toudoo/config/rsync_exclude.txt
>> tokens    D:/Sites/toudoo/lib/form/BaseForm.class.php
>> file+     D:\Sites\toudoo\config/databases.yml
>> dir+      D:\Sites\toudoo\config/doctrine
>> file+     D:\Sites\toudoo\config/doctrine/schema.yml
>> chmod 777 D:\Sites\toudoo\web\uploads
>> chmod 777 D:\Sites\toudoo\cache
>> chmod 777 D:\Sites\toudoo\log
>> chmod 777 D:\Sites\toudoo/symfony
>> chmod 777 D:/Sites/toudoo/web/uploads/assets
>> tokens    D:/Sites/toudoo/config/databases.yml
>> tokens    D:/Sites/toudoo/config/doctrine/schema.yml
>> tokens    D:/Sites/toudoo/config/ProjectConfiguration.class.php
>> tokens    D:/Sites/toudoo/config/properties.ini
>> tokens    D:/Sites/toudoo/config/rsync_exclude.txt
>> tokens    D:/Sites/toudoo/lib/form/BaseForm.class.php

Je ne m'étendrais pas davantage sur l'utilité de tel ou tel dossier. Nous verrons cela progressivement.

On remarquera simplement la création d'un fichier symfony à la racine de notre dossier, qui est simplement un lien vers le fichier /lib/vendor/data/bin/symfony. Encore une fois, on évitera ainsi de trop se fatiguer en écrivant du texte inutile. ;)

Il est temps à présent de créer une application. En gros, une application sera simplement un ensemble de fichiers qui s'appuiera sur les mêmes données d'un site. Nous allons générer la partie utilisateur (frontend). Soit :

php symfony generate:app frontend

Encore une fois, pas mal de blablas en sortie :

>> dir+      D:\Sites\toudoo\apps/frontend\config
>> file+     D:\Sites\toudoo\apps/frontend\config/app.yml
>> file+     D:\Sites\toudoo\apps/frontend\c...licationConfiguration.class.php
>> file+     D:\Sites\toudoo\apps/frontend\config/cache.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/factories.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/filters.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/routing.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/security.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/settings.yml
>> file+     D:\Sites\toudoo\apps/frontend\config/view.yml
>> dir+      D:\Sites\toudoo\apps/frontend\i18n
>> dir+      D:\Sites\toudoo\apps/frontend\lib
>> file+     D:\Sites\toudoo\apps/frontend\lib/myUser.class.php
>> dir+      D:\Sites\toudoo\apps/frontend\modules
>> dir+      D:\Sites\toudoo\apps/frontend\templates
>> file+     D:\Sites\toudoo\apps/frontend\templates/layout.php
>> tokens    D:/Sites/toudoo/apps/frontend/config/settings.yml
>> file+     D:\Sites\toudoo\web/index.php
>> file+     D:\Sites\toudoo\web/frontend_dev.php
>> tokens    D:\Sites\toudoo\web/index.php
>> tokens    D:\Sites\toudoo\web/frontend_dev.php
>> rename    D:\Sites\toudoo\apps/frontend/c...frontendConfiguration.class.php
>> tokens    D:\Sites\toudoo\apps/frontend/c...frontendConfiguration.class.php
>> chmod 777 D:\Sites\toudoo\web\uploads
>> chmod 777 D:\Sites\toudoo\cache
>> chmod 777 D:\Sites\toudoo\log
>> chmod 777 D:\Sites\toudoo/symfony
>> chmod 777 D:/Sites/toudoo/web/uploads/assets
>> dir+      D:\Sites\toudoo\test/functional/frontend

Il est temps de changer légèrement la configuration de notre serveur Web, maintenant que le projet est configuré. On remarque la présence d'un dossier web. C'est en fait le DocumentRoot de notre projet. Cela nous assurera que l'internaute ne pourra farfouiller gaiement dans le fichier de configuration des accès à la base de données par exemple, qui lui est situé à l'extérieur (dans config). On modifie donc le DocumentRoot.

Puis, ouvrez votre projet dans votre navigateur, pour voir ce que ça donne.

Ca a l'air de marcher, mais c'est plutôt hideux, non ? Et pour cause : aucun CSS n'est chargé. En regardant dans le code source, on remarque l'appel à une feuille de style située à l'adresse /sf/sf_default/css/screen.css. Problème, aucun dossier sf n'est présent dans le dossier web/. Que faire ? Simplement mettre en place le bon alias dans votre fichier de configuration, dans la partie correspondante à votre VirtualHost. Vous pouvez également le faire graphiquement avec UwAmp, ce qui est plus simple et plus rapide (je trouve).

Alias /sf "D:\Sites\toudoo\lib\vendor\data\web\sf"

Redémarrez votre serveur Apache pour qu'il prenne en compte vos modifications, et réessayez de visualiser votre site.

Félicitations ! Vous venez de déployer le framework Symfony sur votre premier projet ! Vous avez également déployé un environnement de développement, volontairement éclipsé (comme l'IDE :p) dans ce billet, car il se verra attribué un article à lui tout seul.

N'hésitez pas à faire part de vos remarques. Grand débutant en Symfony, je n'ai sans doute pas tous les réflexes des codeurs les plus aguerris en la matière ! ;)

Définition de la clef RIB

La clef RIB est, par définition, le reste de la division euclidienne du nombre correspondant au code banque, au code guichet et au numéro de compte. Ce nombre, noté R, peut se décomposer comme suit :

Où :

• B est le code banque, sur 5 chiffres,
• G est le code guichet, sur 5 chiffres,
• C est le compte banque, sur 11 chiffres

On démarre directement par les centaines (dix puissance deux) car la clef RIB tient sur deux chiffres (un modulo 97 ne peut être supérieur ou égal à 97).

La formule de calcul d'une clef RIB est donc :

Un numéro de compte peut comporter des lettres. Dans ce cas, il faut appliquer la correspondance suivante :

Calcul de la clef RIB

Si on veut calculer cette clef par programmation (la calculer à la main étant impensable, à moins d'avoir quelques tendances masochistes), il nous faudra modifier cette formule. En effet, le premier terme de cette somme est en puissance 18, ce qui dépasse amplement la taille maximum d'une entier (même non signé) codé sur 32 bits.

La solution ? Appliquer déjà le modulo sur les puissances de 10, et après seulement faire le calcul. Pour ce faire, il est utile de rappeler deux propriétés des modulos :

1. Le modulo d'une somme est égal au modulo de la somme des modulos.
2. Le modulo d'un produit est égal au modulo du produit des modulos.

On applique cette formule dans notre cas :

En procédant de même pour les autres termes de l'addition, on obtient :

On en déduit donc la nouvelle formule de calcul de notre clef RIB :

Or, si on applique la propriété de la somme des modulos de nouveau, on a bien :

Ce qui se calcule à présent très aisément, que ce soit en Javascript ou dans tout autre langage. Voir même à la calculatrice. :)

Pour les plus curieux d'entre vous, le code correspondant est (en MooTools) :

$each($$('.input'), function(item){
	item.addEvent('change', function(e){

		var key = 89 * $('B').value + 15 * $('G').value + 3 * $('C').value;
		key = key % 97;
		key = 97 - key;

		$('rib').set('text', key);
	});
});

Tout simplement. Sachant que seuls les éléments de mon formulaire de calcul de clef RIB ont la classe input.

Libre à vous de l'implémenter dans vos propres programmes. :)

Merci à La Télé Libre pour la réalisation de ce documentaire fort intéressant. :)

Téléchargement du SDK

Dans un premier temps, il nous faudra télécharger le SDK (Software Developpment Kit) qui contiendra toutes les briques logicielles nous permettant de développer facilement des applications complexes. Pour ce faire, il suffit de se rendre sur le site officiel et de télécharger la version correspondante à votre système d'exploitation.

Le fichier téléchargé se présente sous la forme d'une archive. Décompressez la dans un dossier de votre choix.

Le SDK est à présent installé.

Installation et configuration d'Eclipse

Pour développer, nous allons utiliser l'excellent IDE Eclipse, accompagné du plug-in ADT.

Tout d'abord, si ce n'est déjà fait, installez Eclipse. A noter que si vous utilisez déjà une version d'Eclipse (par exemple, dans mon cas, Eclipse PDT All-in-one, spécialisée dans le développement PHP), vous pouvez utilisez cette version et n'êtes donc pas obligés de réinstaller une seconde fois ce logiciel.

A présent, nous allons installer le plug-in ADT, qui nous permettra de développer pour Android. Pour ce faire, il suffit de se rendre dans le menu Help > Install new software.... Puis, cliquez sur Add site. Spécifiez alors l'adresse de téléchargement d'ADT, à savoir : https://dl-ssl.google.com/android/eclipse/.

A présent, sélectionnez le site récemment ajouté, et cochez la case Developper Tools. Il ne vous reste plus qu'à faire suivant suivant suivant, et d'accepter les licences éventuelles.

Redémarrez alors Eclipse comme conseillé.

On configure de suite le compilateur afin qu'il puisse retrouver le chemin du SDK. Dans Windows > Preferences > Android, spécifiez le chemin de votre SDK.

A présent, le plug-in est installé. Nous allons cependant récupérer quelques packages complémentaires, propres à Android, afin notamment de spécifier la cible de notre compilation (à savoir, pour quelle version d'Android nous allons compiler notre programme). On se rend donc dans Window > Android SDK and AVD Manager.

Sélectionnez la seule case qui devrait être disponible, et installez tous les packages disponibles.

Nous voilà à présent prêt pour tester notre installation.

Test de l'émulateur Android

Créons donc un nouveau projet : File > New > Project.

Votre projet doit normalement être créé, et contenir une arborescence relativement complexe.

Je ne m'étendrai pas sur cette architecture pour l'instant. L'étude de celle-ci interviendra dans un prochain billet.

Maintenant, nous allons configurer un terminal virtuel, afin de pouvoir tester sur votre PC directement votre application. On retourne donc dans Window > Android SDK and AVD Manager, et dans la section Virtual devices, on ajoute un nouvel émulateur. Donnez-lui un nom, et une cible. Pour ma part, possédant un Samsung Galaxy tournant sous Android 1.5, je choisis la cible correspondante. Les autres paramètres peuvent être laissés par défaut.

Il ne nous reste plus qu'à tester notre projet. Lancez donc la compilation de votre projet. Dans le fenêtre vous demandant sur quel périphérique le lancer, sélectionnez l'AVD (Android Virtual Device) fraîchement créé. Un terminal devrait alors apparaître. Patientez pendant que le système s'initialise. C'est lent, très lent, je vous l'accorde.

Vous devriez alors finalement voir, si tout fonctionne correctement, un joli Hello World!.

Par la suite, ne fermez surtout pas la fenêtre de l'émulateur. Vous pouvez faire des modifications sur le code source et recompiler. L'émulateur n'aura alors pas à redémarrer, et vous gagnerez donc pas mal de temps. :)

Enfin, dernière petite remarque : si le projet ne compile pas, supprimez tous les fichiers *.xml.out et faîtes un nettoyage (Clean) de votre projet. Android a l'air très capricieux sur ce point. :)

Dans un prochain billet, nous étudierons un peu plus en détails l'architecture d'un projet Android.