Quel pied ! En moins d’1 mois, et avec peu de temps à accorder à mon projet, je suis épaté par l’état d’avancement ! Il est vrai que j’avais déjà lu pas mal de doc précedemment, ce qui aide pas mal à se lancer rapidement.

Symfony est vraiment sacrément bien pensé, et facilite le développement de façon époustouflante. Je ne me lancerait pas dans une comparaison avec d’autres frameworks, je n’en connais aucun suffisamment bien, mais par rapport à un developpement « from scratch », voir même avec un moteur de template, le gain de temps et surtout de qualité est appréciable.

J’apprécie vraiment d’avoir une structure et des conventions à respecter pour mes différents fichiers. Cela est loin d’être une contrainte, mais permet avant tout de bien s’y retrouver.

Au niveau doc, j’utilise beaucoup les tutos officiels, qui sont vraiment très clairs et permettent d’avoir une feuille de route à suivre. Pour la création de mon « backend » (la partie d’administration du site), il m’a suffit de relire la journée du tuto Jobeet consacrée au sujet pour me lancer. Par contre, je n’aime vraiment pas ce qu’ils appellent la doc API… Le formulaire de recherche n’est pas trop futé, et il manque vraiment des exemples concrets pour illustrer les fonctions (on pourrait même imaginer des liens vers les pages de tutos qui y font référence).

Contrairement à ce qui est dit dans les docs Symfony, je ne conseillerai vraiment pas un framework quel qu’il soit à un débutant. Je pense que la période PHP pure est indispensable pour bien comprendre comment cela fonctionne… Même si beaucoup de tâches sont simplifiées en utilisant un framework, il y a toujours des choses à adapter, et pour cela, un certain niveau PHP est nécessaire.

Au niveau ORM, j’avais découvert le framework sous Propel à l’époque… mais j’ai finalement opté pour Doctrine pour mon projet, qui semble être plus dans l’avenir de Symfony. Encore une fois, en m’appuyant sur les tutos, j’ai compris rapidement le fonctionnement et ce changement d’ORM ne m’a pas posé de problèmes.
Pour rentrer un peu plus dans les détails… J’ai commencé par coder un système d’inscription/connexion. Certes, il existe des plugins pour cela… mais j’ai le souvenir d’avoir pas mal galéré à l’utiliser dans mes premiers tests sur Symfony. Et comme j’avais déjà des bouts de codes perso de mes débuts sous Symfony, j’ai préféré me coder mon système d’inscription perso. Très interessant d’ailleurs, il fonctionne bien et j’en suis plutot satisfait !

J’ai enchainé avec la partie « pronostics », où j’ai profité de l’originale mais puissante gestion des formulaires sous Symfony. Comme j’ai quelques besoins spécifiques liés à mon projet, j’ai développé très simplement quelques « validators ».

Actuellement, je suis dans la partie administration… L’ébauche se fait rapidement avec « l’admin generator », mais j’ai pas mal de boulots pour l’adapter à mes besoins.

Je suis beaucoup moins fier de moi au niveau des tests unitaires et fonctionnels… Il y en a tout simplement pas :S C’est vraiment un état d’esprit à avoir… J’espère avoir le déclic un de ces jours… Car même si j’en comprend l’utilité, cela demande une sacré motivation qui passe encore dans mon esprit pour de la perte de temps.

Affaire à suivre donc !

Après de longs mois sans avancer dans mon projet Symfony (framework PHP bien puissant), j’ai enfin pris le temps de m’y remettre. Depuis le temps, j’ai décidé de refaire une installation propre en repartant de la base, et je picorerai dans mon code existant les parties intéressantes (j’avais fait à peine 3 modules…). Pour commencer, je vais présenter mon environnement de développement, ce qui pourra éventuellement donner des idées à des personnes se lançant dans Symfony.

Je suis pro-Windows pour une utilisation courante de mon ordinateur (et oui, je trouve que c’est bien plus stable et plus pratique pour une utilisation quotidienne qu’un Linux ou équivalent), mais j’apprécie la puissance et la liberté du libre lorsque je fais du dev. La solution à mon problème… la virtualisation ! Un petit coup de VirtualBox sur mon Windows Seven, et j’ai installé un Ubuntu 9-10 tout propre.

Petit conseil VirtualBox : l’installation à partir de l’iso est des plus simples (on charge l’iso dans VirtualBox comme si c’était un CD). Une fois l’installation terminée, il ne reste plus qu’à installer les additions clients VirtualBox avec les commandes suivantes :

  * sudo apt-get install build-essential
  * cd /media/cdrom0
  * sudo sh ./VBoxLinuxAdditions.run

On redémarre… et hop, tout est parfait… La fenêtre se redimensionne automatiquement, le copier-coller entre les 2 OS aussi…

Je trouve extrêmement avantageux de coder sur un OS virtualisé. On peut y installer que ce dont on a besoin pour un certain langage, si on se foire dans quelque chose en tripatouillant sa conf, il est facile de soit relancer une sauvegarde de son disque virtuel, soit réinstaller l’ensemble. De mon côté, j’ai un Ubuntu quand je code en Java, un autre quand je code du PHP… C’est clair, propre, efficace :) et vu la puissance inexploitée de nos ordinateurs actuels, ça ne pose guère de problème au niveau performance. (pour info, je dispose d’un quad core « basique » et de 4 Go de RAM… ce qui reste une config assez abordable de nos jours).

A ce Ubuntu, j’ai ajouté le minimum pour coder en PHP… un Apache, un Mysql, du Pear pour Symfony… Voila une petite commande qui peut faire gagner du temps pour installer tout ça.

sudo apt-get install apache2 mysql-server php5 libapache2-mod-php5 php5-mysql

Niveau IDE, j’aime beaucoup Aptana, un Eclipse spécialisé dans le développement Web. A noter, l’installation sur Ubuntu 9-10 diffère des précédentes versions… Ces lignes dans le script de lancement à la place de celles proposées dans la doc d’Aptana résoudra le problème de boutons qui ne se cliquent plus :) (c’est aussi valable pour une installation d’Eclipse sur Ubuntu 9-10 d’après ce que j’ai entendu)

#!/bin/bash
export GDK_NATIVE_WINDOWS=true
"/path/to/aptana/installation/AptanaStudio"

Dernière étape, l’installation de Symfony… Le suivi des premiers chapitres du tutoriel Jobeet est parfait pour ne rien oublier ! J’ai hésité quelques temps entre Propel et Doctrine pour l’abstraction de la BDD… et j’ai tranché pour Doctrine grâce à cet article. Même si je commençais à connaître Propel, Doctrine semble avoir plus d’avenir dans Symfony. Et niveau choix de version de Symfony, je me suis limité à la 1.2, la dernière stable à l’heure actuelle…

Mon projet est donc à présent initialisé, tout est prêt et fonctionnel… « y a plus qu’a donc » !! L’objectif probablement irréalisable est de lancer une première version contenant le minimum vital début janvier… J’y crois peu, surtout vu mon rythme de dev actuel… Sauf si d’ici là, je réussi à me bloquer X heures  par jour que pour ça. Affaire à suivre donc !

Bonjour,

Commençons par expliquer ce qu’est l’admin generator de Symfony… Globalement, en 2 temps 3 mouvements, et quelques lignes de codes, cela nous permet de créer une interface pour administrer notre base de données. Typiquement, on se crée un phpmyadmin pour notre partie administration.

J’ai donc créer un petit « layout », le schéma de page globale à chaque page d’admin, avec un menu en haut pour accéder à chacune de mes tables, et j’ai laissé faire la magie Symfony :

menu_admin

une page d'admin... certes, c'est pas très joli ces inputs sombres... mais c'est lié à mon thème d'Ubuntu, qui permet de ne pas se fatiguer les yeux :)

Malgré tout, mieux vaut avoir quelques connaissances assez pointues en PHP pour comprendre comment ça fonctionne, et l’adapter à ses besoins… Car les « fatal error » ou autres « parse error » s’accumulent…

Déjà, premier réflexe, ajouter des méthodes __toString() à chacun de ses classes de la base de données objet.

Exemple, dans le fichier lib/model/MaTable.php :

class MaTable extends BaseMaTable
{
  public function __toString()
  {
    return $this->getName();
  }
}

Cela lui permettra de savoir quoi afficher quand vous faites des liens entre plusieurs tables (la méthode toString est une « méthode magique », qui est appelé quand on fait un echo sur un objet).

Autre déconvenue qui m’a pris bien plus de temps à résoudre… Quand vous faites des liens entre des tables, par exemple, une table qui relie les utilisateurs à des droits :

doselectjoinall

le doSelectJoinAll

L’idée est d’avoir, dans la liste, le nom du droit et le nom de l’utilisateur… et nom leurs id respectifs… La solution st venu du doSelectJoinAll, dans le fichier de configuration generator.yml :

      list:
        title: Droits des utilisateurs
        display: [user_id, credential_id, credential_comment]
        peer_method:  doSelectJoinAll

Très facilement, j’ai pu créer mes propres modules à la structure proposée par Symfony… Par exemple, ce module qui permet de créer des QCM, réalisé en « Ajax », à l’aide de Mootools…

qcm

création d'un QCM en javascript

Un petit défaut sur le HTML/CSS de base… Le filtre est une bonne idée… mais à moins d’avoir un écran de 50″, le div de filtre recouvre les champs de la table… Du coup, je vais devoir modifier le CSS pour le passer en dessous de la table…

filtre

un recouvrement de filtre pas très joli

Voila pour les grandes lignes… J’ai encore pas mal à explorer sur l’admin generator, mais l’essentiel est que, en pas trop longtemps, j’ai réussi à répondre à mon besoin ! Et c’est bien là l’intérêt d’un framework !

Depuis 2 semaines, je me suis (enfin) lancé dans mon projet Symfony ! Il s’agit de coder la nouvelle version de mon site, le PJEA (site de pronostics sur le sport automobile).

La première chose à noter, c’est que c’est TOTALEMENT différent de coder son projet perso que de suivre un tuto, genre Jobeet :) On a beau recopier à la main le bout de code, le copier-coller… on se dit qu’on comprend ce que ça fait…. mais quand on part d’une feuille blanche, c’est bien différent… Les débuts ont été laborieux…

Mes outils

Je vais commencer par détailler mes outils pour ce nouveau projet.

Bien que toujours fidèle à mon Windows Vista, il faut se rendre à l’évidence… coder sous Symfony demande d’être sous un système Linux… Donc, la parade, pour pas non plus changer toutes mes habitudes… la virtualisation !

J’ai donc installé VirtualBox, et virtualisé avec Ubuntu 8. L’installation du packetage minimum fait (un apache, un mysql…), j’ai commencé à chercher un éditeur plus sympathique que Vim… J’ai jeté mon dévolu sur Eclipse PDT 2.0. Très pratique, beaucoup plus maniable que Vim… De l’autocomplétion, une analyse du code en live pour les oublis de  » ;  » ou autre… A côté de ça, un terminal, pour pouvoir lancer les commandes Symfony… et hop, en avannt !

Les premières lignes

Le projet généré, la première étape a été de créer le schema.yml, le fichier qui permet de définir la base de données. Histoire de commencer en douceur, je me suis limité en nombre de tables… 7 tables pour l’instant, avec le minimum de champs dedans. Le premier objectif est de pouvoir s’inscrire au site, se connecter, et faire des pronostics. Quand cela marchera, j’ajouterai les autres fonctionnalités (et elles sont nombreuses…).

Pour le module de connexion/inscription, ma première étape, j’ai préféré le recodé entièrement au lieu d’utiliser le plugin sfGuard.Ca me permettait de commencer en douceur… Je me suis quand même inspiré du plugin, quand j’étais bloqué dans mon code.

Ca m’a pris du temps, mais c’est bon, à présent, ça fonctionne bien… Avec pose de cookie si le joueur veut être connecté à la prochaine visite… de l’ajax (utilisation de Mootools, une librairie légère est très sympahique à utiliser).

Je me suis ensuite attaqué au module « prono », qui permet au joueur de faire ses pronostics. Pas mal de complications là… J’ai crée mon propre « validator » pour mon formulaire (on ne doit pas pouvoir pronostiquer 2 fois le même pilote).

De grosses difficultés avec la gestion des timestamp et des datetime… La comparaison ne voulait pas se faire… Heureusement, après de longues recherches, la fonction strtotime() m’a sauvée la vie :)

Côté formulaire aussi, pré-remplir les <select> avec les valeurs précédemment rentrées par le joueur (si il veut modifier son prono, il falllait que le formulaire soit pré-remplit avec les anciennes pilotes choisis). J’ai demandé un peu d’aide sur le forum de la communauté Symfony… J’y reviendrai dans la partie « Bilan »…

Au final, après ces 2 semaines (pas intensives non plus, je vous rassure :) ), je suis arrivé à mon premier objectif. Mes 2 modules fonctionnent ! Je vais pouvoir attaquer de nouvelles fonctionnalités.

Bilan personnel

Quel bonheur la programmation « agile ». Certes, il y a beaucoup de fichiers, beaucoup de dossiers… mais comme tout est agencé de façon parfaitement logique, on peut apporter des modifications au fiur et à mesure du développement. On commence par le minimum de ce que doit faire la fonction, et on étoffe au fur et à mesure.

La refactorisation est aussi indispensable. Dès que quelque chose fonctionne, il faut prendre le temps de réorganiser le code (placer ce qui a rapport aux données dans les fonctions liées à la gestion de la base de données « objet »… créer des classes séparées… ne pas répéter son code en différents endroits… et toujours bien respecter le principe MVC (Modèle-Vue-Controleur).

Dans les déceptions… Un peu déçu quand même par la communauté Symfony… J’ai posé 2 questions sur le forum… La première, j’ai du la relancer pour que quelqu’un s’intéresse à moi… la deuxième attend toujours… Et pourtant, ce n’est pas des questions que j’ai posé par flemme de chercher… J’ai d’ailleurs non sans mal trouvé la réponse à ma deuxième question tout seul… Je me suis donc auto répondu… Bien évidemment, je suis conscient que ça n’est pas leur métier de répondre aux questions, et qu’ils doivent voir passer pas mal de questions stupides tout les jours… mais bon, ça fait pas trop esprit ouvert… Pis la première personne a m’avoir répondu a envoyé de façon bien stupide un lien vers un autre topic, que j’avais déjà lu, et qui ne répodnait pas du tout à ma question…

Pour finir, dans mon approche de la découverte de ce framework… J’ai pas pris la meilleure décision je pense… Je me suis lu la totalité de la doc (un genre de gros pdf de 350 pages, expliquant les bases de tout le fframework) avant de commencer. Ca m’a pris du temps, et au final, je suis forcé de reprendre pleins de parties… Car c’est quand on est vraiment confronté au problème qu’on comprend l’intérêt de telle ou telle fonction.

Mon petit conseil donc… Lire le minimum pour commencer… A la limite les introductions à chaque partie du framework… Et aller lire en détail seulement quand on se retrouve confronté au problème (les filtres par exemple, qui permettent de faire des actions avant ou après chaque requête – typiquement, l’utilisateur n’est pas connecté, on regarde si il a un cookie pour se connecter automatiquement) – j’étais passé à côté quand je l’ai lu la première fois.. j’ai du tout me relire cette partie quand j’étais confronté au problème.

Conclusion

A suivre… Et oui, je suis loin d’en avoir terminé avec ce nouveau site ! Mais plus je maîtriserai le framework, et plus le développement ira vite ! J’ai déjà pas mal gagné en rapidité par rapport au tout début.

A partir d’aujourd’hui, je vais ajouter de nouvelles tables, et de nouveaux modules à mon application… Développement agile… On avance petits pas par petits pas !

A bientot donc, pour de nouvelles aventures :)

Jour 15 : Flux RSS

Bizarre… Obligé de supprimer la première ligne de chaque flux RSS :

<?xml version="1.0" encoding="utf-8"?>

Sinon, il me renvoie une « syntax error »… Bon, du coup, mon flux risque d’être un peu moins valide… mais tant pis ! Je me pencherai plus en détail sur la question quand j’en aurai réellement besoin…

Excepté cela, ce tuto se fait très facilement… pas de difficultés particulières !

Jour 16 : le Web Service

Beaucoup de copier-coller pour moi dans cette partie… qui ne m’intéresse pas outre mesure… Et toujours ce problème de déclaration de version xml…

Sans compter un problème dans la partie du formulaire d’affiliation… Avec les actions du routing… Il s’avère que j’avais oublié de vider le fichier _form.php…

Une petite erreur dans leur code ( lib/model/… au lieu de lib/test/…). Flemme de m’inscrire pour ouvrir un ticket pour le signaler… Tant pis.

Au suivant !

Jour 17 : La recherche

Très impressionnant ! En réutilisant le Zend Framework, on met en place en quelques lignes un très bon formulaire de recherche !

Quelques soucis de droits au début… Heureusement, le très bon site d’Ubuntu était là : http://doc.ubuntu-fr.org/droits#changer_les_permissions

Jour 18 : Ajax

Un formulaire de recherche dynamique… pas transcendant comme Ajax… j’aurai préféré un truc plus impressionnant et plus utile… Heureusement, d’autres tutos Ajax existent pour Symfony !

Jour 19 : Internationalisation

Quelle puissance ça ! Il devient très simple de rendre un site multi-lingue. Cela me servira très certainement dans mes futurs sites !

Petit problème sur mon lien pour lister les jobs d’une catégorie, sur ma page d’accueil… Mais bon, l’essentiel est d’avoir compris le principe :)

Jour 20 : Les plugins

Encore une nouvelle façon d’organiser les fichiers de son projet… J’avoue ne pas être vraiment fan pour le moment… Pour un très gros projet, pourquoi pas… car sur un projet moyen, ça complique plus qu’autre chose…

Plus ça va, plus mon jobeet devient un grand n’importe quoi :) je tetse des choses par ci par là… je fais pas gaffe à les enlever… Du coup, au final, j’ai même pas un tiers des tests qui passent :) ma console devient toute rouge si je tente un test:all :)

Jour 21 : Design

Ca commence à sentir la fin… Je lis en diagonale ce jour… Pas intéressé pas re-designer mon Jobeet… Certes, il y a de jolis thèmes de proposés, mais passons…

Jour 22 : Le cache

Sympa le cache… Mais mon action index ne l’entend pas de cette façon… elle ne veut pas se mettre en cache… la bos en haut à gauche reste désespérement jaune… Pour l’action new, cependant, ça fonctionne ! C’est déjà ça !

Je me rappelle de l’époque où j’avais créé par moi même mon système de cache… Et ba, j’était bien courageux à l’époque… Car malgré les heures passées dessus, ils ne vaut pas un 1/100 de celui ci ! Bref, il faut vraiment arrêter de sans cesse réinventer la roue :)

Jour 23 : Déploiement de Jobeet

Dernier jour décisif, qui, je l’espère, va définitivement me convaincre de passer à ce framework, que j’ai découvert il y a déjà quelques mois, mais que je n’ai jamais vraiment utilisé. Ce maxi tutorial m’a permit de mieux m’en imprégner…

Lors de ma découverte de Ruby On Rails, l’étape de déploiement, justement, m’avait fait hésité à y passer… Voyons pour Symfony !

Après lecture du tuto, il s’avère qu’il ne traite que de la configuration du serveur… Mais une question me tiraille… Comment mettre à jour des changements dans la structure de la base de données ? Jusque là, la commande build détruisait tout les précédents enregistrements… Quand la question se posera (lors du déploiement de mon premier projet sous Symfony), j’explorerai plus en détails la question…

Jour 24 : Conclusion

Un dernier jour pour conclure tout ce que l’on a vu ensemble pendant ces 23 jours. Je me rend compte qu’il me faudra approfondir les notions de slots, partials et components… Pas encore très claires dans mon esprit (cela permet de mieux organiser le code, mais les différences entre ces 3 entitées étant faibles… je ne sais pas vraiment laquelle utiliser pour chaque situation).

A présent, je vais pouvoir me lancer dans mon projet perso ! Déjà, avec toutes les bases apprises par l’intermédiaire de Jobeet, j’y vois plus clair, et je peux m’attaquer à la réflexion sur les différents modules et l’architecture nécessaires à mon site.

A bientot, pour de nouvelles aventures Symfony !

,

Jobeet : jours 7 à 14

Jour 7 : La page des catégories

Un nouveau module… démarche intéressante, relativement différente du premier module « job ». Découverte de la pagination… aucune difficulté particulière…

Jour 8 : les tests unitaires

Quelqu’un a réussi à se motiver à faire des tests pour chaque fonction écrite depuis le début du tuto ? moi, non… Clair que c’est beau dans l’idée, mais il faut avoir une sacrée rigueur pour tout tester ! J’essaierai quand même de m’y mettre lorsque je ferai mon premier site sous Symfony…

Jour 9 : les tests fonctionnels

Vraiment énorme ça… Encore une fois, il faut la motivation pour bien coder ça proprement… mais après, c’est nickel ! Plus de risques de paumer des fonctionnalités après avoir codé de nouveaux trucs…

Et le tuto est bien fait… Apprentissage bien en douceur…

Jour 10 : les formulaires

Un peu brouillon ce tuto… tout arrive en vrac… pas méga clair… mais bon, au final, ça semble fonctionner… juste un problème de droit pour l’upload des logos sur le serveur…

Jour 11 : formulaires et tests

Chose intéressante, on apprend qu’on peut relativement facilement utiliser des bouts de librairie Symfony sur d’autres projets… genre le cache, le formulaire…

Sinon, rien de bien particulier durant cette journée. Les bases sont acquises, les progrès sont moins impressionnant que pendant les premiers jours…

Jour 12 : administration

Sacrément puissant… une interface d’admin parfaitement configurée en quelques lignes… reste que pour l’insant, tout le monde peut y aller… Les droits seront surement au programme des prochains jours…

Jour 13 : sécurisation de l’administration

intéressant de découvrir ce plugin, sfGuard… ou comment réaliser en 3 clics un controle d’accès… bon, piour mon futur projet Symfony, je pense quand même développer par moi même cette partie… je pense qu’il est assez complexe de mettre en place cela dans un site…

Au passage, mes tests fonctionnels ne sont plus passés dans le backend… il faudrait pouvoir simuler un utilisateur connecté… à voir…

Jour 14 : Voler des ses propres ailes…

Bon, encore une fois, je fais mon rebelle… j’en profite pas pour dévelloper un truc par moi même… je passe direct à la semaine 3…

A bientot !

,

Jobeet : jour 5 et 6

Jour 5 : Routage

Le routage permet de faire correspondre une URL à une page donnée. L’avantage du routage Symfony, c’est qu’il est facilement configurable, et modifiable par la suite sans devoir tout reprendre ses fichiers.

Comme le montre l’exemple dans le tuto, il est très simple de transformer une adresse indigeste du type : /job.php?id=1 en quelque chose de plus claire et plus facilement référencable par des moteurs de recherches (du type : /job/sensio-labs/paris-france/1/web-developer).

Pleins de nouvelles découvertes, pas mal d’améliorations par rapport à la version 1.1 de Symfony. Et pas de difficultés particulières…

Jour 6 : Propel et les critères

Très intéressant… on apprend à jouer avec propel, la couche qui permet l’abstraction de la base de données. Syntaxe assez particulière, assez déroutante quand on a l’habitude d’utiliser du SQL… Cela semble plus compliqué à utiliser… mais peut être plus puissant… A voir à l’usage !

Au passage… il m’a fallut renommer une variable dans le template indexSuccess du module job… soit j’ai loupé une étape du tuto… soit il riques d’y avoir quelques utilisateurs qui ne comprendront pas pourquoi ça ne fonctionnera pas (pour info, c’est l’objet $jobs à mettre).

Quelques difficultés aussi, lors de la modification du fichier de configuration, pour mettre en variable « globale » le nombre de jours actifs par annonce… Obligé de supprimer manuellement le fichier de cache, sinon, grosse erreur en rouge =)

Le reste se déroule bien… Une journée bien complète… La proposition finale de développer par soi même la page des catégories… faut de la motiv’ ! On verra le prochain jour !

Aie aie… je prend de plus en plus de retard dans mon calendrier de l’avent Symfony ! Mon site d’annonces ne sera jamais prêt à temps pour être mis sous le sapin le 24 :P

Aujourd’hui, double ration… jour 3 et 4 !

Jour 3 : rien à signaler… tutorial plus long que les 2 précédents, mais plus concret… on commence à avoir un truc qui fonctionne à la fin de la journée ! Le YAML (format de fichier très simple); toujours aussi pratique et rapide. On crée une base de données en quelques lignes !! Et tout cela est très facilement modifiable par la suite.

Jour 4 : quelques problèmes à signaler… par rapport à ma configuration serveur… j’ai du adapter légèrement les adresses des images dans le « layout » (le design html de base) afin qu’elles s’affichent. Sans compter les problèmes de liens… faut vraiment que je reprenne cette conf’ serveur en détail dans les prochain jours…

Sinon, c’est à partir de ce jour là que l’on rentre vraiment dans le vif du sujet ! Inutile de copier-coller bêtement les bouts de codes… il faut se plonger un peu dedans pour bien comprendre le fonctionnement du framework.

Un des principal avantage d’un framework comme symfony est l’ordonnancement des fichiers. Tout est bien rangé, décomposé en applications / modules…, avec un peu d’expérience, on retrouve très vite ce que l’on cherche.

A demain, pour le routage sous Symfony ! Une autre spécificité importante du framework !

Jobeet : jour 2

Après avoir installé la nouvelle version de Symfony pendant le jour 1, configuré 2-3 trucs sur le serveur… le jour 2 nous détaille ce que nous allons programmer !

Il s’agit d’un site d’offres d’emploi (vu le nom, c’est pas non plus une grande surprise). Quelques schémas pour voir à quoi ressemblera l’interface, la liste des fonctionnalités (dont quelques trucs intéressant, comme la possibilité pour n’importe quel webmaster d’ajouter un module sur son site, avec les offres d’emplois !).

A part ça, rien de particulier… en 15 minutes de lecture, c’est fini ! on est loin de l’heure de travail quotidien promise ^^

Jobeet : jour 1

Ayé, je me lance dans le maxi tutorial Symfony… (bon, ok, déjà 3 jours de retard).

Comme pour Askeet, le suspens est de mise… on ne sait pas à quoi servira le site que l’on va créer à l’issu de ce premier jour (m’enfin, avec un nom comme ça, on se doute que ça va tourner autour d’offres d’emploi ou quelque chose du genre…).

Le 21ème jour, pour Askeet, c’était le développement d’un thème choisi par la communauté (en l’occurence, un moteur de recherche). Cette fois, c’est un « design day », où la communauté proposera et choisira le thème du site). Toujours aussi sympa cette intéractivité avec les lecteurs !

Passons aux choses sérieuses… l’objectif de ce premier jour est l’installation de Symfony 1.2. Bien évidemment, j’ai voulu faire mon rebelle, et regarder dans la doc officielle comment installer Symfony sans passer par l’archive (j’aime pas trop, je préfère du apt-get ou du pear).

Gros échec… J’ai pas réussi en pear (il trouve rien à installer), ni en apt-get (il m’installe un symfony 1.0…). Donc, retour au tuto, et téléchargment / décompression & Co du fichier source. Placé dans /lib/vendor/… ça me fait toujours peur de toucher à tout ce que je comprend pas sous Linux ^^ tant pis, c’est qu’une virtualisation d’Ubuntu de toute façon…

Pis la commande magique :php lib/vendor/symfony/data/bin/symfony -V

Qui me renvoie bien Symfony 1.2.0. Ouf ! ça, c’est fait !!

Quelques légères modifs dans la création de l’application… rien de trop violent pour ceux qui connaissent déjà Symfony…

En ce qui concerne la configuration du serveur, j’ai encore fait mon rebelle… Quelques modifs dans /etc/apache2/sites-enabled…

Et hop, voila qui semble bon ! localhost/jobeet me renvoie la page de départ de Symfony, toujours aussi classe au passage !

Pour finir, avec le svn… pas trop bien capté l’explication dans le tuto… je suis reparti chercher celle du tuto d’Askeet : http://www.symfony-project.org/askeet/1_0/en/1 que je trouve bien plus claire pour un débutant en symfony…

Voila, cette première journée Jobeet s’achève ! Pas de code de fait, mais la nouvelle version de Symfony est installée, le svn aussi., l’application générée… bref, on a tout pour commencer les choses sérieuses demain !!