Introduction

Si vous avez rencontré à un moment donné de votre projet symfony2 la problématique du stockage de médias en base de données vous vous êtes forcément posé la question suivante : Comment créer un nouveau type de données doctrine2 avec symfony2 ? En effet, il n’existe que peu de types de base avec Doctrine2, pour des soucis de généricité :

• string
• integer
• smallint
• bigint
• boolean
• decimal
• date
• time
• datetime
• text
• object
• array
• float

Comme trame de cet article, nous allons tenter de créer une nouvelle entité Media qui sera stockée en base de données en type blob.

Créer un nouveau type de données doctrine2 à symfony2 : le type Blob

Deux solutions s’offrent à vous pour créer votre nouveau type :

• Créer un nouveau dossier dans votre bundle dans lequel vous implementerez votre nouveau type : src/MyApp/MyBundle/ORM

• Implémenter votre nouveau type directement dans le vendor dédié : vendor/doctrine-dbal/lib/Doctrine/DBAL/Types

Sachant que la seconde méthode aura pour avantage de rendre votre type utilisable par tous les bundles mais l’inconvénient de ne pas fournir un bundle clé en main, c’est à dire un bundle comprenant la déclaration des types dont il a besoin.

Pour notre exemple, nous allons privilégier la première méthode : src/MyApp/MyBundle/ORM

C’est dans ce dossier que vous allez pouvoir créer vos nouveaux types de données. Pour notre exemple, réalisez une classe BlobType qui héritera de la classe AbstractPlatform. Vous devrez déclarer obligatoirement les fonctions suivantes :

• public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
• public function convertToDatabaseValue($value, AbstractPlatform $platform)
• public function convertToPHPValue($value, AbstractPlatform $platform)

Ces fonctions vous permettent de définir un comportement pour vos champs. Vous pouvez par exemple avoir besoin de crypter un mot de passe avant de l’enregistrer en base de données.

<?php
namespace  MyApp\MyBundle\ORM;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\Type;

/**
 * Type that maps an Blog SQL to php objects
 */
class BlobType extends Type
{
    const BLOB = 'blob';

    public function getName()
    {
        return self::BLOB;
    }

    public function getSQLDeclaration(array $fieldDeclaration, AbstractPlatform $platform)
    {
        return $platform->getDoctrineTypeMapping('blob');
    }

    public function convertToDatabaseValue($value, AbstractPlatform $platform)
    {
        return ($value === null) ? null : base64_encode($value);
    }

    public function convertToPHPValue($value, AbstractPlatform $platform)
    {
        return ($value === null) ? null : base64_decode($value);
    }
}

Ajouter le nouveau type Doctrine2 à notre bundle Symfony2

Une fois notre type créé, il faut indiquer à Doctrine2 que celui-ci est disponible à l’utilisation. Pour cela, il nous faut enregistrer celui-ci grace à la fonction registerDoctrineTypeMapping(). Celle-ci permet de charger notre nouveau type de données dans la fonction boot() du bootstrap de notre bundle :

<?php
// src/MyApp/MyBundle/MyAppMyBundle.php
namespace MyApp\MyBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;
use Doctrine\DBAL\Types\Type;

class StoreAdBundle extends Bundle
{
    public function boot()
    {
        $em = $this->container->get('doctrine.orm.entity_manager');

        // Ajout des nouveaux types à notre entity manager
        Type::addType('blob', 'MyApp\MyBundle\ORM\BlobType');
        $em->getConnection()->getDatabasePlatform()->registerDoctrineTypeMapping('blob', 'blob');
    }
}

Votre nouveau type est désormais configuré et prêt à l’emploi dans vos entités.

Utiliser le nouveau type Doctrine2 dans une entity de notre bundle Symfony2

Pour terminer notre exemple d’ajout d’une entité Media persistée au format blob en base de données à notre projet, voici ce à quoi pourrait ressembler celle-ci :

<?php
// src/MyApp/MyBundle/Entity/Media.php
namespace MyApp\MyBundle\Entity;

use Gedmo\Mapping\Annotation as Gedmo;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Table(name="media")
 * @ORM\Entity()
 */
class Media
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length=100)
     */
    protected $name;

    // Utilisation de notre nouveau champs blob
    /**
     * @ORM\Column(type="blob")
     */
    protected $file;

    /**
     * @ORM\Column(type="string", length=100)
     */
    protected $mime_type;

    /**
     * @ORM\Column(type="integer", length=100)
     */
    protected $size;

    /**
     * @ORM\Column(type="string", length=5)
     */
    protected $extension;

    // getters
    // setters
    // ...
}

En mettant à jour votre base de données via la commande

$ php app/console  doctrine:schema:update --force

Vous devriez désormais avoir une table media possédant votre nouveau champ blob.

Si vous avez besoin d’une aide ou d’une expertise pour vos projets symfony vous pouvez nous contacter.

Cet article présente certaines des nombreuses fonctionnalités disponible de l’outil WordPress. De nombreuses documentations sur ce sujet sont disponibles sur la toile mais la plus complète se trouve sur le site officiel codex.wordpress.org. L’idée de cet article est de vous permettre une rapide prise en main des fonctionnalités essentielles et de vous accompagner en vous proposant un fil conducteur simple dans les coulisses de ce séduisant CMS …

Pour installer WordPress, si c’est déjà fait, allons-y !

A quoi sert le back office de WordPress

Le back office de WordPress est un espace réservé, accessible par un login et un mot de passe.

Une fois connecté dans cette espace vous pourrez alors:

• Gérer le contenu de votre site (Articles, Pages, Médias, Liens)
• Modérer les commentaires déposés par les internautes
• Modifier l’apparence du site (par l’utilisation de thèmes)
• Ajouter des extensions (plugins) pour enrichir en fonctionnalités votre site
• Administrer les utilisateurs
• …

La navigation s’effectue par le menu qui est, présent sur la gauche de votre écran, le contenu des différents liens se chargeant dans la zone principale au centre. L’ergonomie de WordPress vous séduira par sa simplicité et sa rapide prise en main.

Qu’elle est la différence entre un ‘article’ et une ‘page’

La façon dont sont sauvegardées les données en base:

Les articles comme les pages sont des informations enregistrées dans la même table wp_posts mais avec une valeur différente pour le champ post_type selon si c’est un article (post) ou une page (page). La différence est donc faite dans l’utilisation.

La façon dont ils sont utilisés:

Les pages sont utilisées pour afficher des informations pérennes sans réelle limite dans le temps. Les liens vers les pages sont généralement regroupés sous la forme d’un menu afin de proposer une navigation pour votre site. Il est possible de les hiérarchiser afin de constituer des sous-menus, des sous-sous-menu …

Les articles sont généralement utilisés pour afficher des informations d’actualité sur un sujet précis. Il est possible de les catégoriser.

D’autres usages sont possibles avec les articles en fonction de votre imagination:

• Réaliser un encart promotionnel
• Réaliser un slideshow
• Afficher une ‘citation du jour’
• …

Comment créer un article

Il suffit de cliquer dans le menu sur l’item Articles > Ajouter ou bien Articles > Tout les articles > Ajouter

Saisissez un titre puis le contenu.

Vous pouvez lui associer des catégories que vous pouvez créer à votre convenance.

Vous pouvez lui associer des mots-clés pour un meilleur référencement (si vos mots-clés sont pertinents).

Une fois votre contenu prêt, vous pourrez alors:

• L’enregistrer comme brouillon, puis le retravailler ultérieurement
• Visualiser un aperçu dans votre front office
• Le publier

Comment créer une page

Il suffit de cliquer dans le menu sur l’item Pages > Ajouter ou bien Pages > Toutes les pages > Ajouter

Saisissez un titre puis le contenu.

Vous pouvez hiérarchiser vos pages en définissant une page parent. Une page ne peut avoir qu’un seul parent, mais elle peut avoir plusieurs pages enfants. Vous pouvez définir un ordre d’affichage en renseignant le champ order. La plus petite valeur correspond à la première position dans le menu.

Une fois votre contenu prêt, vous pourrez alors:

• L’enregistrer comme brouillon, puis le retravailler ultérieurement
• Visualiser un aperçu dans votre front office
• Le publier

L’éditeur de WordPress

Vous pouvez éditer votre contenu à l’aide de l’éditeur WYSIWYG (What You See Is What You Get) ou bien directement saisir les balises HTML. A vous de choisir le mode d’édition qui vous convient le mieux.

Il est également possible d’utiliser un éditeur disposant de plus de fonctionnalités. Il suffit pour cela de cliquer sur « Afficher/cacher les options avancées (touches: Alt+Shift+Z) ».

L’insertion de média (image, vidéo, son) s’effectue à l’aide des boutons d’actions situés au-dessus de l’éditeur. Les interfaces pour l’insertion de média sont très intuitives.

Les permalinks

Le permalink correspond à l’URL (Unified Ressource Locator) permettant d’accèder à votre page ou votre article. C’est l’identifiant Web d’un contenu bien précis de votre site.

Par défaut le permalink est constitué de l’URL de votre site suivi de /?p=id-post Ou ‘id-post’ est l’identifiant du contenu dans votre base de donnée MySQL (Table wp_post).

Si vous souhaitez travailler le référencement Web de vos contenus, il peut être intéressant d’optimiser cette URL avec des mots clés au lieu d’utiliser l’écriture par défaut. Pour cela il faut commencer par définir la chaîne de formatage de vos permalinks dans l’onglet Réglages > Permaliens

Assurer vous d’avoir mis les bons droits sur votre dossier Web, car les modifications de ce paramètre entraine la création d’un fichier .htaccess à la racine de votre site Web.

Pour plus d’informations voici un lien sur comment utiliser les permalinks sur le site http://codex.wordpress.org

Une fois vos réglages effectués, il ne vous reste plus qu’à définir les URL de vos Articles ou de vos Pages directement dans la page d’édition de ces derniers:

Comment fonctionne les commentaires

Les commentaires sont des messages laissés sur un article ou une page par des internautes. C’est une fonctionnalité qui est active par défaut sur l’ensemble de votre site. Les commentaires se configure dans Réglages > Discussion

Voici une petite FAQ (Foire Aux Questions):

Comment désactiver les commentaires ?

Vous pouvez activer/désactiver les commentaires de manière globale, c’est à dire sur tout le site:

Ou bien de manière plus ciblée, c’est à dire sur une page ou un article bien précis. Pour cela aller sur l’édition de la page ou de l’article pour la/lequel vous souhaitez régler l’affichage des commentaires, puis afficher les options d’écran:

et cocher l’option discussion

Une nouvelle fenêtre pour configurer les discussions liées à votre page ou votre article est maintenant disponible un peu plus bas sur votre écran. Vous pouvez alors activer ou non les commentaires sur la page ou l’article édité.

Qui peut laisser un commentaire ?

Vous pouvez imposer ou non le renseignement d’informations personnelles avant de pouvoir déposer un commentaire. Autrement dit, acceptez-vous ou non des messages de personnes anonymes. Par défaut le nom et le mail sont des champs obligatoires. Vous pouvez modifier cela commme suit:

Les commentaires déposés par les internautes sont ils visibles sur mon site ?

Cela dépend encore une fois de vos réglages, par défaut les commentaires nécessitent une validation de la part de l’administrateur du site. Il ne vous reste plus qu’à faire vos réglages.

Une fois votre site en ligne, il est possible que vous receviez des commentaires saisis par des ‘robots’, c’est à dire des programmes informatiques. Ces commentaires sont facilement reconnaissables car souvent leurs contenus sont sans rapport avec le contenu de la page commentée. Une bonne solution pour lutter contre ces messages indésirables est l’utilisation de plugin par exemple Akismet Mais vous pouvez très bien les supprimer manuellement

Ajouter des Thèmes

Les thèmes correspondent à un ensemble de fichiers qui définissent la structure HTML de vos pages ainsi que le design par le biais des feuilles de styles (CSS) et des images.

Vous pouvez télécharger de nombreux thème sur le site officiel de WordPress http://wordpress.org/extend/themes/

Lorsque vous avez téléchargé un thème au format ‘zip’, décompresser le, puis ajouter le dossier ainsi obtenu dans le dossier wp-content/themes de votre projet WordPress. Aller dans l’onglet Apparence > Thèmes.

Le nouveau thème doit apparaître parmi les thèmes disponibles. Il ne vous reste plus qu’à l’activer.

Pour visualiser ce nouveau thème, rendez-vous sur la partie FrontOffice de votre site Web.

Ajouter des Plugins

Les plugins sont des fonctionnalités supplémentaires qui peuvent être ajoutées à votre site Web. Il en existe un grand nombre et ce chiffre est en augmentation constante.

Vous pouvez télécharger des plugins sur le site officiel de WordPress http://wordpress.org/extend/plugins/

Lorsque vous avez téléchargé un plugin au format ‘zip’, décompresser le, puis ajouter le dossier ainsi obtenu dans le dossier wp-content/plugins de votre projet WordPress. Aller dans l’onglet Extensions.

Le nouveau plugin doit apparaître parmi les plugins disponibles. Il ne vous reste plus qu’à l’activer.

Gérer les utilisateurs

WordPress est une application multi-utilisateur permettant donc à plusieurs personnes de gérer les contenus diffusés par l’outil. Différents niveaux de droits peuvent être associés à un utilisateur à savoir:

• Administrateur
• Abonnée
• Editeur
• Auteur
• Contributeur

Pour gérer les utilisateurs aller sur l’onglet Utilisateurs du menu

Paramétrage de votre site

Changer le titre et le slogan

Pour modifier le titre de votre site/blog ainsi que le slogan, informations souvent mises en avant côté FrontOffice, Aller dans l’onglet Réglages > Général.

Modifier la page d’accueil

Par défaut, WordPress liste les derniers articles publiés sur votre page d’accueil. Ceci peut être modifié pour ne lister qu’un certain nombre d’articles, ou encore pour afficher une page ‘statique’ à la place. Pour cela aller dans l’onglet Réglages > Lecture.

Maintenant il ne vous reste plus qu’a travailler vos contenus !

Après chaque modification réalisée côté backoffice, retournez sur la partie front, c’est à dire la partie publique de votre site, et visualisez le rendu.

N’hésitez pas à laisser vos commentaires.

Si vous souhaitez une formation plus avancée sur WordPress vous pouvez également nous contacter.

Introduction

Gérer les utilisateurs inscription, connexion, droits d’accès, etc.. a toujours été un plaisir avec symfony grâce aux plugins:

• sfGuardPlugin (propel)
• sfDoctrineGuardPlugin (doctrine)

Ce n’est pas bien plus dur avec Symfony2 ! Cela est même simplifié au maximum, bien que dépaysant au début. Le bundle FOSUserBundle répond aux mêmes problématiques mais fluidifie les choses, les rend plus intuitives.

FOSUserBundle : Installation

Il vous faut tout d’abord récupérer les sources du bundle et les placer dans le dossier vendor. Pour cela, 2 solutions s’offrent à vous :

1) Installation de FOSUSerBundle en clonant le dépôt git

$ git clone https://github.com/FriendsOfSymfony/FOSUserBundle.git vendor/bundles/FOS/UserBundle

2) Installation de FOSUSerBundle via les dépendances git

Ajoutez les lignes suivantes dans votre fichier deps :

[FOSUserBundle]
    git=git://github.com/FriendsOfSymfony/FOSUserBundle.git
    target=bundles/FOS/UserBundle

Puis mettez à jour les vendors :

$ php bin/vendors install

Cette solution a l’avantage de permettre à n’importe qui travaillant avec vous sur le projet de ne pas avoir à se soucier de quelles sont les vendors à installer et où les trouver. Il lui suffira de mettre à jour les vendors.

Une fois FOSUserBundle ajouté aux vendors, il vous faut l’activer dans le Kernel:

<?php
// app/AppKernel.php

public function registerBundles()
{
    $bundles = array(
        // ...
        new FOS\UserBundle\FOSUserBundle(),
    );
}

… Et ajouter le namespace qui va bien dans l’autoload:

<?php
// app/autoload.php

$loader->registerNamespaces(array(
    // ...
    'FOS' => __DIR__.'/../vendor/bundles',
));

Si vous avez encore des doutes sur l’utilité des namespaces ou que vous êtes sceptiques quant à son utilisation, je vous renvoie à ce très bon article de Pascal MARTIN sur le sujet.

Créer votre entity User en surchargeant l’utilisateur de FOSUserBundle

Pour hériter d’un bundle avec Symfony2, il suffit de définir le bundle parent dans votre classe :

<?php
// src/MyApp/UserBundle/MyAppUserBundle.php

namespace MyApp\UserBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

class MyAppUserBundle extends Bundle
{
    public function getParent()
    {
        return 'FOSUserBundle';
    }
}

Votre UserBundle hérite maintenant de toutes les vues, actions…du bundle FOSUserBundle. Vous pouvez donc créer un nouvel utilisateur héritant de celui de base, tous les fonctionnalités de FOSUserBundle s’appliqueront à cet utilisateur :

<?php
// src/MyApp/UserBundle/Entity/User.php

namespace MyApp\UserBundle\Entity;

use FOS\UserBundle\Entity\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user")
 */
class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
}

Configuration de FOSUserBundle

Il vous faut maintenant configurer le bundle. Pour cela, éditez votre fichier config.yml:

# app/config/config.yml
fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    # Permet de renseigner la nouvelle entity utilisateur
    user_class: MyApp\UserBundle\Entity\User

Votre bundle est désormais operationnel, vous pouvez mettre à jour votre base de données :

$ php app/console doctrine:schema:update --force

A ce stade là, vous devez normalement avoir une table fos_user dans votre base de données, et un dossier vendor/bundles/FOS/UserBundle contenant la hierarchie habituelle d’un bundle Symfony2.

Générez ensuite les getters et setters de votre nouvelle entity :

$ php app/console doctrine:generate:entities MyAppUserBundle:User

Vos entités sont operationnelles, il ne vous reste plus qu’à gérer vos formulaires. Tout d’abord, le formulaire utilisateur :

$ php app/console doctrine:generate:form MyAppUserBundle:User

Maintenant, en lançant la commande

$ php app/console

Vous avez désormais toute une floppée d’actions possibles grâce au bundle FOSUserBundle :

fos
  fos:user:activate                     Activate a user
  fos:user:change-password              Change the password of a user.
  fos:user:create                       Create a user.
  fos:user:deactivate                   Deactivate a user
  fos:user:demote                       Demote a user by removing a role
  fos:user:promote                      Promotes a user by adding a role

Un coup d’oeil à la suite de cet article vous permettra de faire un tour d’horizon rapide de ce bundle pour une utilisation optimale.

Ajoutez des champs à votre entity User

Vous souhaitez également que l’utilisateur renseigne nom, prénom, date de naissance, etc… lors de son inscription, que faire ?

Avec symfony 1.x, il fallait créer une nouvelle classe Profil qui était embarquée dans le formulaire de création d’un utilisateur.

Avec symfony2, nul besoin d’utiliser une logique aussi complexe que les formulaires embarqués. Il suffit de créer une nouvelle entity dans votre bundle qui héritera des attributs et mécanismes inhérents à l’utilisateur FOSUserBundle mais possédant également vos attributs. Pour fil conducteur nous allons ajouter ensemble un lieu d’habitat pour l’utilisateur. Pour cela, créez un nouveau bundle que vous appelerez UserBundle qui heritera de FOSUserBundle.

<?php
// src/MyApp/UserBundle/Entity/User.php

namespace MyApp\UserBundle\Entity;

use FOS\UserBundle\Entity\User as BaseUser;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user")
 */
class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    // Ajoutez vos attributs ici, un attribut *location* de type *text* pour notre exemple :
    /**
     * @ORM\Column(type="text")
     */
    protected $location;

}

Il vous faut ensuite modifier le formulaire d’inscription. Pour cela il vous faut étendre celui de base fournis par le bundle FOSUserBundle en ajoutant vos champs personnalisés. Pour continuer sur notre exemple, voici comment ajouter notre fameux champ location :

<?php

namespace MyApp\UserBundle\Form\Type;

use Symfony\Component\Form\FormBuilder;
use FOS\UserBundle\Form\Type\RegistrationFormType as BaseType;

class RegistrationFormType extends BaseType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        parent::buildForm($builder, $options);

        // Ajoutez vos champs ici, revoilà notre champ *location* :
        $builder->add('location');
    }

    public function getName()
    {
        return 'myapp_user_registration';
    }
}

Il vous faut maintenant préciser à votre fichier de config quel formulaire utiliser pour l’inscription des utilisateurs :

# app/config/config.yml
fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    # Permet de renseigner la nouvelle entity utilisateur
    user_class: MyApp\UserBundle\Entity\User
    # Permet de renseigner le nouveau formulaire d'inscription
    registration:
    form:
        type: myapp_user_registration

Votre entity est désormais à jour. Vous pouvez désormais actualiser votre base de données, votre table fos_user contiendra vos nouveaux champs :

$ php app/console doctrine:schema:update --force

Routing, actions et templates utilisés par FOSUserBundle

Vous devez en tout premier lieu importer toutes les routes du bundle :

# app/config/routing.yml
fos_user_security:
    resource: "@FOSUserBundle/Resources/config/routing/security.xml"

fos_user_profile:
    resource: "@FOSUserBundle/Resources/config/routing/profile.xml"
    prefix: /profile

fos_user_register:
    resource: "@FOSUserBundle/Resources/config/routing/registration.xml"
    prefix: /register

fos_user_resetting:
    resource: "@FOSUserBundle/Resources/config/routing/resetting.xml"
    prefix: /resetting

fos_user_change_password:
    resource: "@FOSUserBundle/Resources/config/routing/change_password.xml"
    prefix: /profile

Découvrons ensemble les routes que FOSUserBundle a généré pour nous en utilisant une commande Symfony2 listant les routes :

$ php app/console router:debug

Vous devriez voir apparaître (en plus de vos autres routes) les routes suivantes :

fos_user_security_login           ANY      /login
fos_user_security_check           ANY      /login_check
fos_user_security_logout          ANY      /logout
fos_user_profile_show             GET      /profile/
fos_user_profile_edit             ANY      /profile/edit
fos_user_registration_register    ANY      /register/
fos_user_registration_check_email GET      /register/check-email
fos_user_registration_confirm     GET      /register/confirm/{token}
fos_user_registration_confirmed   GET      /register/confirmed
fos_user_resetting_request        GET      /resetting/request
fos_user_resetting_send_email     POST     /resetting/send-email
fos_user_resetting_check_email    GET      /resetting/check-email
fos_user_resetting_reset          GET|POST /resetting/reset/{token}
fos_user_change_password          GET|POST /change-password/change-password

Vous avez également ces routes dans le routing interne à FOSUserBundle, où vous pouvez voir quelle est l’action cible de la route. Par exemple, pour la gestion des profils, jetons un coup d’oeil au fichier de routing :

<!-- vendor/bundles/FOS/UserBundle/Resources/config/routing/profile.xml -->
<routes xsi:schemaLocation="http://symfony.com/schema/routing http://symfony.com/schema/routing/routing-1.0.xsd">
  <route id="fos_user_profile_show" pattern="/">
    <default key="_controller">FOSUserBundle:Profile:show</default>
    <requirement key="_method">GET</requirement>
  </route>
  <route id="fos_user_profile_edit" pattern="/edit">
    <default key="_controller">FOSUserBundle:Profile:edit</default>
  </route>
</routes>

Comme vous pouvez le remarquer, les fichiers de routing fournis par FOSUserBundle sont au format xml.

Gérer les droits d’accès des utilisateurs avec Symfony2

Tout est désormais fonctionnel, vous n’avez plus qu’à restreindre l’accès aux pages souhaitées. Cela se passe dans le fichier de configuration security.yml :

security:
    providers:
        fos_userbundle:
            id: fos_user.user_manager

    encoders:
        "FOS\UserBundle\Model\UserInterface": sha512

    firewalls:
        main:
            pattern: ^/
            form_login:
                provider: fos_userbundle
                csrf_provider: form.csrf_provider
            logout:       true
            anonymous:    true

    # C'est ici que tout se passe : qui a accès à quoi ?
    access_control:
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/, role: ROLE_ADMIN }

    role_hierarchy:
        ROLE_ADMIN:       ROLE_USER
        ROLE_SUPER_ADMIN: ROLE_ADMIN

La partie importante à bien comprendre est celle de l’access_control : Toutes les routes prefixées par /admin/ necessiteront le rôle ROLE_ADMIN,

Il vous suffit de préfixer les routes à protéger par /admin/ et le mécanisme de sécurité se mettra en oeuvre. Là ou il vous fallait faire un backend sécurisé et un frontend avec symfony 1.x, ou encore user du fichier security.yml pour une gestion plus fine des accès. Vous pouvez désormais gérer au cas par cas les espaces sécurisés simplement grâce à leurs routes !

Récupérer et utiliser l’utilisateur dans une action avec Symfony2

L’utilisateur est stocké en session, dans le contexte de l’application. Mais récupérer celui-ci sous forme d’objet dans une action peut vite devenir un casse-tête, bien que cela soit utile dans de nombreuses situations. Voici une bonne façon de faire :

$user = $this->container->get('security.context')->getToken()->getUser()

Vous pouvez ensuite manipuler cet objet comme bon vous semble et récupérer vos attributs nouvellement créés :

$user->getlocation()

Gérer l’utilisateur et ses droits d’accès dans un template twig avec Symfony2

Comment tester si l’utilisateur possède les bons droits d’accès dans un template avec Symfony2? Un jeu d’enfant avec twig ! En effet, twig dispose d’une kyrielle de fonctions de base :

{# L'utilisateur est-il connecté ? #}
{% if is_granted("IS_AUTHENTICATED_REMEMBERED") %}
    {# L'utilisateur est connecté ! #}
    <a href="{{ path('fos_user_security_logout') }}">Déconnexion</a>

    {# L'utilisateur est-il admin ? #}
    {% if is_granted('ROLE_ADMIN') %}
        {# L'utilisateur est admin ! #}
        <a href="{{ path('admin') }}">Administration</a>
    {% endif %}
{% else %}
    {# L'utilisateur n'est pas connecté ! #}
    <a href="{{ path('fos_user_security_login') }}">Connexion</a>
    <a href="{{ path('fos_user_registration_register') }}">Inscription</a>
{% endif %}

Twig vous permet également de récupérer l’utilisateur facilement :

{% if is_granted("ROLE") %}
    Bien le bonjour {{ app.user.username }} !
{% endif %}

Utilisez vos propres templates pour décorer FOSUserBundle

Pour utiliser vos templates, il va falloir surcharger les templates existant du bundle FOSUserBundle en respectant la hierarchie imposée par celui-ci. Pour notre exemple, nous allons modifier le template d’inscription d’un nouvel utilisateur. Pour respecter la hierarchie du bundle, créez un template register.html.twig dans un nouveau dossier Registration de votre UserBundle :

#src/MyApp/UserBundle/Resources/views/Registration/register.html.twig
{% extends "::base.html.twig" %}

{% block content %}
    <form action="{{ path('fos_user_registration_register') }}" {{ form_enctype(form) }} method="POST" class="fos_user_registration_register">
        {{ form_widget(form) }}
        <div>
            <input type="submit" value="{{ 'registration.submit'|trans({}, 'FOSUserBundle') }}" />
        </div>
    </form>
{% endblock %}

Le template d’inscription sera dorénavant décoré par le template de base. Ce mécanisme vous permet d’utiliser une des grandes forces de Twig: l’héritage de templates !

Envoyez un email de confirmation pour la création d’un utilisateur

Vous rêviez de pouvoir valider automatiquement vos utilisateurs en leur envoyant un email de confirmation avec un lien à cliquer pour valider ladite inscription ? FOSUSerBundle l’a fait !

En effet, il existe une fonctionnaltié toute prête permettant cet envoi d’email et validation de compte au-to-ma-tique. Cependant, celle-ci est désactivée par défaut. Pour l’activer,rien de plus simple :

# app/config/config.yml
fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    # Permet de renseigner la nouvelle entity utilisateur
    user_class: MyApp\UserBundle\Entity\User
    # Permet de définir quel service de mail utiliser
    # On utilise twig_swift pour pouvoir envoyer un email en HTML
    service:
        mailer: fos_user.mailer.twig_swift
    # Permet de renseigner le nouveau formulaire d'inscription
    registration:
        form:
            type: myapp_user_registration
        # Permet la validation automatique du compte par envoi d'un email
        confirmation:
            enabled:    true
            from_email:
                # Adresse de l'expediteur
                address:        noreply@monsiteweb.com
                # Nom de l'expediteur
                sender_name:    Admin de monsiteweb.com
        # Permet de définir le template de l'email à envoyer (en html)
        email:
            template: MyAppMonBundle:User:registration.email.twig

Il ne vous reste plus ensuite qu’à définir le template que vous souhaitez utiliser pour l’envoi d’email :

{# src/MyApp/MonBundle/Resources/views/User/registration.email.twig #}

{% block subject %}Confirmation d'inscription{% endblock %}

{% block body_text %}
{% autoescape false %}
Bonjour {{ user.username }} !

Vous devez confirmé voter inscription [....] en cliquant sur le lien suivant : {{ confirmationUrl }}

Amicalement,
Administrateur de monsiteweb.com
{% endautoescape %}
{% endblock %}

{% block body_html %}
{#
    Vous pouvez ici définir le HTML que vous souhaitez ou même utiliser la force de twig, à savoir l'inclusion de template : 
    include 'MyAppMonBundle:User:registration_email.html.twig'
#}
{% endblock %}

Utiliser la ligne de commande pour gérer vos utilisateurs avec FOSUserBundle

Le bundle FOSUSerBundle vous propose toute une kyrielle de commandes permettant de gérer vos utilisateurs :

1) Création & activation

$ php app/console fos:user:create monutilisateur test@example.com motdepasse
$ php app/console fos:user:activate monutilisateur
$ php app/console fos:user:deactivate monutilisateur

2) Gestion des rôles

$ php app/console fos:user:promote monutilisateur ROLE_ADMIN
$ php app/console fos:user:demote testuser ROLE_ADMIN

3) Changement de mot de passe

$ php app/console fos:user:change-password monutilisateur nouveaumotdepasse

Erreurs courantes avec FOSUserBundle

1) Problèmes de configuration de FOSUserBundle

Problème :

The child node "user_class" at path "fos_user" must be configured.
The child node "db_driver" at path "fos_user" must be configured.
The child node "firewall_name" at path "fos_user" must be configured.

Solution : Vous n’avez pas configuré l’un des éléments necessaire au bon fonctionnement de FOSUserBundle, à savoir :

fos_user:
    db_driver: orm # other valid values are 'mongodb', 'couchdb' and 'propel'
    firewall_name: main
    user_class: MyApp\UserBundle\Entity\User

Problème :

ErrorException: Warning: class_parents(): Class MyApp\Entity\User does not exist and could not be loaded in */vendor/doctrine/lib/Doctrine/ORM/Mapping/ClassMetadataFactory.php line 223

Solution : Vous avez mal configuré votre user_class dans app/config/config.yml. Vérifiez que votre namespace est bon, que votre classe se situe bien là ou vous l’avez définie.

2) Problèmes de surcharge de l’entity User de FOSUserBundle

Problème : Vous n’arrivez pas à surcharger le formulaire d’édition de profil de FOSUserBundle, rien à y faire vous avez cette erreur :

Neither property "username" nor method "getUsername()" nor method "isUsername()" exists in class "FOS\UserBundle\Form\Model\CheckPassword"

Solution : La surcharge du formulaire d’édition de profil de FOSUserBundle est un peu différente de celle du formulaire d’inscription. En effet, la fonction à surcharger dans le cas du formulaire d’inscription est buildForm(), or pour l’édition de profil, c’est la fonction buildUserForm() qu’il faut surcharger !

<?php
namespace MyApp\UserBundle\Form\Type;

use Symfony\Component\Form\FormBuilder;
use FOS\UserBundle\Form\Type\ProfileFormType as BaseType;

class ProfileFormType extends BaseType
{
    public function buildUserForm(FormBuilder $builder, array $options)
    {
        parent::buildUserForm($builder, $options);
        // On ajoute nos champs :
        $builder->add('location');
    }

    public function getName()
    {
        return 'myapp_user_profile';
    }
}

Conclusion

Symfony2 est amélioré par rapport à son predecesseur vieillissant. Là où symfony proposait un plugin agreable d’utilisation mais rendant les choses vite complexe pour une utilisation avancée, Symfony2 propose une approche plus pragmatique du problème : Faites ce que vous voulez, comme vous le voulez et où vous le voulez en héritant du bundle de base. Ce framework ainsi que ses bundles sont des outils de grande qualité ! N’hésitez pas à nous faire vos retours.

Si vous souhaitez une formation sur les frameworks symfony ou Symfony2 contactez-nous.

Avant d’installer WordPress, je vous recommande la lecture de cet article sur comment mettre en place un environnement de développement pour réaliser un site avec php et mysql.

Récupérer les sources de WordPress

Commencez par créer un dossier de travail (si ce n’est pas déjà fait). Puis récupérez les sources de WordPress en les téléchargeants:

• Version anglaise
• Version française

Décompressez l’archive ainsi récupérée dans votre dossier de travail. Assurez-vous de bien avoir positionné les bons droits sur le dossier contenant les fichiers sources de WordPress.

Pour les systèmes Debian et dérivés (Ubuntu, …), exécutez les commandes suivantes:

$ sudo chgrp www-data -R WORKSPACE/WP_PROJECT
$ sudo chmod 775 -R WORKSPACE/WP_PROJECT

Remplacez WORKSPACE par l’emplacement de votre répertoire de travail et WP_PROJECT par le nom de votre projet. Pour vérifier que les droits sont correctement positionnés, vous pouvez lancer la commande suivante:

$ ls -l WORKSPACE

Vous devez obtenir le résultat suivant:

drwxrwxr-x  6 USER www-data 4096 2011-01-23 10:45 WP_PROJECT

Installer WordPress

Ouvrez un navigateur puis accéder à l’URL que vous avez défini pour votre site (ex: http://local.domain/) L’application détecte alors que c’est votre première connexion (par l’absence de configuration) et vous propose alors de procéder à l’installation de WordPress. Le processus d’installation de WordPress est simple et intuitif. Les informations qu’il vous faudra fournir sont:

• les paramètres d’accès à la base de donnée MySQL
• le titre de votre site
• le login, le mot de passe et le mail de l’administrateur

Voici une serie d’écran vous présentant l’installation de WordPress 3.2.1

Durant cette étape, il vous faudra renseigner les informations de connexion à la base de donnée.

Voilà vous venez d’installer WordPress !

Accèder à l’espace d’administration (Back-Office)

Pour l’administration de votre site il faudra aller à l’adresse suivante http://local.domain/wp-admin puis saisir vos login et mot de passe définis durant la phase d’installation pour pouvoir accéder à l’espace d’administration de votre site.

Visualiser votre site (Front-Office)

Pour visualiser votre site, rendez-vous à l’adresse http://local.domain

Bonne découverte !

La réussite d’un évènement est multifactorielle : choix du lieu, des intervenants, des commanditaires, fluidité dans le déroulement des manifestations, communication ciblée et efficace. Elle est le fruit d’une réflexion à laquelle l’organisateur se doit de consacrer toute son énergie. En outre, se concentrer sur son coeur de métier, c’est aussi apprendre à gagner du temps sur les tâches à moindre valeur ajoutée. L’informatique et l’automatisation des processus a déjà permis de gagner en efficacité dans de nombreux domaines. Dans celui de l’évènementiel, il s’agit de gérer des centaines, parfois des milliers de participants de plus en plus exigeants en matière de contenu et de prestations. Pour inscrire un évènement dans la durée il est également essentiel de convaincre les intervenants (scientifiques, politiques, business, artistiques…) de sa reconnaissance et de sa pérennité.

Ainsi un participant satisfait communiquera, reviendra, et sera un vecteur de notoriété et d’influence. Celles-ci permettront de solliciter les meilleurs intervenants et ainsi de suite.

IDCI consulting, en collaboration avec le service FOCAL de l’Université Claude Bernard Lyon 1, s’est intéressé au sujet et à répondu à cette problématique par la création de Symposium.

Symposium : De la communication à la logistique, un ensemble de fonctionnalités intégrées !

Cet outil Web est idoine pour tout organisateur ambitieux puisqu’en plus de proposer une automatisation des processus logistiques :

• inscription,
• relance,
• génération et envoi de documents,
• affectation des inscrits aux diverses manifestations
• …

il permet, en quelques clics, de générer un support de communication (Site Web), que ce soit en amont pour lui donner une visibilité sur la toile et diffuser en temps réel l’information ou en aval pour retrouver, via un espace personnalisé, des publications, des supports postés par les intervenants ou tout type de document (factures, reçus, attestations de présence, badges, certifications, …)

Les avantages de Symposium

Outre son efficacité opérationnelle, Symposium, de par sa licence GNU GPL garantit aux utilisateurs une évolution constante grâce à leur collaboration et à leur convergence vers un objectif commun : maintenir l’outil à niveau maximum de performance par la mise à jour de fonctionnalités toujours plus innovantes.

C’est le retour vers une concurrence pure et parfaite telle que décrite par les économistes d’avant-garde, la capacité d’accession à des outils performants n’étant plus un critère de différenciation. Les organisateurs de congrès se devront d’être innovants et performants sur leur coeur de métier, et ce, quelle que soit leur taille ou leur influence. Ainsi l’utilisation collaborative de Symposium contribuera à dynamiser le marché de l’organisation d’évènements par l’innovation et la créativité dans ce domaine

Des vidéos de présentation sont en cours d’élaboration. Dans cette attente, n’hésitez pas à nous contacter. pour que nous vous proposions une séance de démonstration à distance

Pourquoi mettre en place un environnement de développement ?

Afin de vous faciliter la prise en main et la compréhension du fonctionnement de la plupart des applications réalisées avec les technologies PHP et MySQL (WordPress, Joomla, Drupal, PrestaShop, Magento, …) je vous recommande de travailler localement c’est à dire directement sur votre ordinateur. Celui-ci devra être configuré pour pouvoir faire fonctionner:

• Un serveur Web interprétant le langage PHP
• Le SGBDR MySQL pour stocker les données de votre application.

Ainsi vous pourrez plus facilement:

• Développer le site (modifier les templates et vos fichiers css) sans avoir à synchroniser vos fichiers sur un serveur.
• Tester des plugins et des thèmes rapidement et sans impacter votre site une fois celui-ci en ligne.
• Ne pas vous soucier d’une éventuelle mauvaise manipulation qui pourrait porter atteinte à vos données.

Idéalement utiliser un outil de gestion de version (revision control software en Anglais) afin de garder l’historique de vos changements apportés à votre site (révisions). Si vous devez travailler en équipe, c’est un outil indispensable à mettre en place dès le début de votre projet (Subversion, Git). Enfin, dans le cas d’un projet professionnel, je vous recommande vivement l’utilisation d’un logiciel de suivi de problèmes (bug tracker en Anglais)

Choisir le serveur HTTP

Il existe différents serveur HTTP que vous pouvez installer sur votre ordinateur. Voici une liste non exhaustive:

• Apache
• Lighttpd
• Cheeroke
• NGNIX
• …

Voici un comparatif des différents serveurs HTTP. Pour commencer je vous recommande d’utiliser le serveur HTTP Apache dans sa version 2.x. C’est le serveur HTTP le plus repandu au monde (netcraft), il dispose de nombreux modules et c’est certainement l’un des plus complet en terme de fonctionnalités. De plus il est packagé prêt à l’emploi sur de nombreux systèmes d’exploitations.

• WAMP ou EasyPHP sous Windows
• MAMP sous MacOs
• Depuis des dépôts (apt, yum) sous linux

Sous système Debian et dérivés (Ubuntu, …) voici la commande pour pouvoir installer tout ce dont vous aurez besoin pour pouvoir faire fonctionner WordpPress:

$ sudo apt-get install apache2 mysql-server php5 php5-mysql phpmyadmin

Une fois que vous aurez installé votre serveur HTTP sur votre ordinateur, vous pourrez alors consulter la page Web par défaut délivrée par celui-ci en requêtant votre localhost. Pour cela ouvrez un navigateur web puis renseignez l’url suivante: http://localhost.

Configuration du serveur WEB pour interpréter le langage PHP

Pour pouvoir faire fonctionner votre application PHP, il faut que votre serveur HTTP soit capable d’interpréter ce langage. Dans le cas du serveur Apache vous avez le choix entre deux méthodes:

• PHP en module Apache
• PHP en CGI

De nombreux sites exposent les différences entre ces deux méthodes. Par défaut, le serveur Apache interprétera le code PHP par la méthode « module Apache », mais ceci est paramétrable. Pour vérifier que votre serveur HTTP est bien configuré pour exécuter du code PHP, vous pouvez créer un fichier nommé phpinfo.php est le déposer à la racine Web de votre serveur HTTP:

• c:\wamp\www\ avec WAMP sous Windows
• c:\EasyPHP\www avec EasyPHP sous Windows
• /Applications/MAMP/htdocs avec MAMP sous MacOS
• /var/www sous Linux
• …

Dans ce fichier écrire le code PHP suivant:

<?php phpinfo(); ?>

Puis requêter l’URL http://localhost/phpinfo.php. Vous devez obtenir le résultat suivant:

Utiliser les VirtualHosts

Virtual hosting ou hébergement virtuel est une méthode qui permet d’héberger plusieurs noms de domaine sur un serveur physique utilisant une seule adresse IP. Cela permet de mieux exploiter les ressources (mémoire, processeur) du serveur en les partageant pour les besoins de plusieurs sites.

C’est également une bonne pratique à mettre en place lorsque vous travaillez localement. Cela permet de choisir des noms de domaines différents pour chacun de vos sites par exemple:

• http://mon_site1
• http://mon_site2
• …

au lieu des URLs du type

• http://localhost/mon_site1
• http://localhost/mon_site2
• …

Cela vous permet également de stocker des sites web sans respecter une arborescence stricte. C’est à vous d’associer à un nom de domaine, un emplacement physique d’un site sur le système de fichiers du serveur.

Voici à quoi ressemble la déclaration d’un Virtual Host pour apache. Remplacer local.domain par le nom de domaine que vous souhaitez utiliser et domain_path par l’emplacement physique du dossier contenant les fichiers du site web à associer.

<VirtualHost *:80>
    ServerName local.domain
    ServerAdmin webmaster@local.domain.fr

    DocumentRoot /home/user/workspace/domain_path

    <Directory /home/user/workspace/domain_path>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Order allow,deny
        allow from all
   </Directory>

    ErrorLog /var/log/apache2/error_local.domain.log
    # Possible values include: debug, info, notice, warn, error, crit, alert, emerg.
    LogLevel warn
    CustomLog /var/log/apache2/access_local.domain.log combined
</VirtualHost>

Pour redémarrer le service apache sur système Debian et dérivés (Ubuntu, …)

$ sudo /etc/init.d/apache2 restart

ou

$ sudo service apache2 restart

Modifier une entrée DNS localement: Ajouter une ligne dans le fichier hosts

Le Domaine Name System DNS est un service permettant d’établir une correspondance entre une adresse IP et un nom de domaine. Lorsque vous saisissez une URL dans votre navigateur, votre ordinateur va réaliser une résolution de nom c’est à dire récupérer l’adresse IP associée au domaine demandé. Cette adresse IP ainsi obtenue va permettre ensuite d’envoyer une requête HTTP à destination du bon serveur. Il est également possible de définir localement des couples Adresse IP <-> Nom de domaine.

Lors d’une résolution DNS votre ordinateur va commencer par faire une 1] Resolution local, c’est à dire rechercher si l’entrée DNS recherchée est définie localement. Si oui, utilisation de cette adresse, sinon il va effectuer une 2] Résolution distante. Le serveur DNS interrogé retournera la reponse si il connait l’association recherchée, sinon il interrogera un autre serveur DNS et ainsi de suite jusqu’à l’obtention de 3] La réponse. L’ordinateur à l’origine de la demande mettra 4] En cache la réponse ainsi obtenue pour d’éventuelles futures requêtes et pourra ainsi contacter le serveur corespondant au domaine recherché.

Pour définir localement une association entre une adresse IP et un nom de domaine il faut ajouter une entrée dans le fichier ‘hosts’.

Dans le cas d’un développement local, pour associer l’adresse local.domain à votre propre machine c’est à dire le localhost il faut ajouter l’entrée 127.0.0.1 local.domain.

Sous système Debian et dérivés (Ubuntu, …), éditer le fichier hosts:

$ sudo vi /etc/hosts

Puis ajouter l’association Adresse IP <-> Nom de domaine souhaitée.

127.0.0.1       local.domain

Pour vérifier la prise en compte de votre changement par votre système, effectuer une requête ping. Vous devez obtenir le résultat suivant:

$ ping local.domain
PING localhost (127.0.0.1) 56(84) bytes of data.
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.041 ms
64 bytes from localhost (127.0.0.1): icmp_seq=2 ttl=64 time=0.033 ms
64 bytes from localhost (127.0.0.1): icmp_seq=3 ttl=64 time=0.033 ms
64 bytes from localhost (127.0.0.1): icmp_seq=4 ttl=64 time=0.027 ms
....

Si vous obtenez le message suivant:

$ ping local.domain
ping: unknown host local.domain

C’est que vous n’avez pas ajouté correctement l’entrée dans votre fichier hosts.

Paramètrer MySQL

MySQL est un SGBDR (Système de Gestion de Base de Donnée Relationnelle). C’est un logiciel libre développé sous double licence en fonction de l’utilisation qui en est faite :

• Dans un produit libre: licence publique générale GNU (GPL)
• Dans un produit propriétaire: licence payante

Pour les applications comme WordPress, Joomla, Drupal, PrestaShop, Magento, … il faudra renseigner, durant la phase d’intallation, les informations pour la connexion à la base de donnée MySQL.

Une bonne pratique consiste à créer un utilisateur avec des accès bien définis sur une base, plutôt que d’utiliser le même compte sur toutes les bases (par exemple le compte root). Cela permet un meilleur cloisonnement et offre ainsi une meilleure sécurité. Ce n’est pas une obligation dans un environnement de développement mais vivement recommandé dans un environnement ‘dit’ de production. Pour cela vous pouvez utiliser l’outil phpMyAdmin, accessible depuis un navigateur, et procéder comme suit:

Vous pouvez également exécuter les requêtes SQL suivantes en replaçant user par le nom de l’utilisateur que vous voulez créer et *** par le mot de passe

CREATE USER 'user'@'%' IDENTIFIED BY '***';

GRANT USAGE ON * . * TO 'user'@'%' IDENTIFIED BY '***' WITH MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0 MAX_USER_CONNECTIONS 0 ;

CREATE DATABASE IF NOT EXISTS `user` ;

GRANT ALL PRIVILEGES ON `user` . * TO 'user'@'%';

En résumé vous venez de créer une base nommée user et vous avez créé un utilisateur user avec le mot de passe user disposant de tous les droits sur cette base.

host: localhost
nom de la base de donnée: user
utilisateur: user
mot de passe: user

Ces informations vous seront demandées lors de l’installation d’une application PHP qui utilise le SGBDR MySQL pour stocker des données.

Si vous souhaitez une assistance pour la mise en place d’un environnement de développement pour vos équipes ou encore une aide pour le déploiement et la migration de votre site, vous pouvez nous contacter.

A quoi sert WordPress

WordPress est un CMS (Content Management System : système de gestion de contenu), qui vous permet de facilement rédiger du contenu sur le ou les sujets de votre choix et de les mettre à disposition (ou non d’ailleurs) sur le Web.

Historiquement WordPress fut créé pour répondre à la problématique du Blog. C’est un conteneur de ‘posts’, c’est à dire des articles agglomérés au fil du temps sur différents sujets.

Depuis sa création en 2003, WordPress a beaucoup évolué et offre aujourd’hui de nombreuses fonctionnalités, sa communauté est très active et elle propose de nombreux plugins et extensions.

De plus WordPress est un outil gratuit développé sous licence Open Source GPLv2+ avec le langage PHP.

WordPress est devenu une formidable boite à outils pour la réalisation de site web. Cependant d’autres solutions existent et dans certain cas se montre plus intéressante que WordPress. Par exemple, si vous souhaitez réaliser une boutique en ligne, il vaudra mieux s’orienter vers une solution métier ou des outils de type prestashop.

Comment fonctionne WordPress

WordPress est une application PHP qui est destinée à fonctionner sur le Web. Pour pouvoir utiliser WordPress il faut un serveur HTTP configuré pour pouvoir interpréter le langage PHP et un Système de Gestion de Base de Donnée Relationnelle (SGBDR) : MySQL.

Voici un schéma mettant en scène chaque application dans le traitement d’une requête HTTP reçue par un serveur web hébergeant un site fait sous WordPress:

Quand une 1] requette HTTP est reçue par le server Web, celui-ci récupère le fichier ‘index’ de WordPress défini dans 2] le Virtual Host. Ce fichier PHP ainsi que tous ceux inclus par ce dernier sont interprétés par 3] le moteur de rendu PHP. Les contenus stockés dans la base de données MySQL sont 4] Requêtés par SQL. Le rendu HTML une fois réalisé est envoyé en 5] réponse HTTP au client web (= navigateur : Firefox, chromium, etc).

L’application se compose de:

• Un Front-Office. qui sera la partie visible des internautes lorsque ceux-ci navigueront sur votre site web accessible par une URL bien définie.

• Un Back-Office dédié à l’administration de votre site Web accessible par l’URL d’accueil de votre site web suivi de /wp-admin (par défaut). Cet espace est réservé et nécessitera de vous authentifier par un login et un mot de passe.

Avantages et inconvénients de WordPress

Avantages:

• Un Back-Office complet, facile à prendre en main.
• Un Front-Office très facilement personnalisable grâce aux thèmes.
• De nombreux thèmes et plugins téléchargeables gratuitement.
• C’est un outil Open Source et gratuit soutenu par une communauté très active.

Inconvénients:

• La réalisation d’un thème nécessite des connaissances basiques dans les langages: HTML CSS et PHP.
• Ce n’est pas la solution miracle pour la réalisation de tout type de site, il est spécialisé dans la mise en ligne de contenus facilement éditables (CMS).

Dans quels cas utiliser WordPress ?

L’utilisation de WordPress peut être un bon choix pour:

• La réalisation d’un blog.
• La réalisation d’un site vitrine.
• La réalisation d’un site d’information.

Dans les cas suivants il est souvent préférable de choisir une autre solutions:

• La réalisation d’un site e-commerce (ventes de produits en ligne).
• Plus généralement, la réalisation d’une application web orienté métier.

Si vous avez un projet web à réaliser et que vous souhaitez un avis extérieur dans le choix de la technologie à utiliser, n’hésitez pas à nous contacter.

Ce tutoriel explique comment mettre en place un projet Symfony depuis la sandox sous Ubuntu. Le but de ce post est de proposer une recette clé en main pour ne rien oublier lors de la création de vos nombreux projets avec le framework PHP Symfony.

Si vous ne savez pas encore ou stocker votre projet, je vous recommande de créer un dossier workspace à la racine de votre Home Directory

mkdir $HOME/workspace

Téléchargement de la sandox de Symfony

Vous pouvez récupérer la sandox depuis la page ‘installation’ sur le site du projet Symfony puis télécharger la version sandbox pour Symfony 1.4.

Ou bien directement par ces liens pour télécharger la sandox avec la dernière version du framework Symfony 1.4x

• symfony-1.4.x.tgz
• symfony-1.4.x.zip

Ou enfin

wget http://www.symfony-project.org/get/sf_sandbox_1_4.tgz  $HOME/workspace

Extraction de Symfony

Décompresser l’archive récupérée.

tar -zxvf $HOME/workspace/sf_sandbox_1_4.tgz

Puis renommer ce dossier en PROJECT_NAME.

cp -R $HOME/workspace/sf_sandbox_1_4 $HOME/workspace/PROJECT_NAME

 Configurer un vhost apache

Nous allons créer (ou éditer si vous l’avez déjà créé) un fichier vhost. Dans notre cas nous avons un fichier vhost nommé sfProject dans lequel nous déclarons tous les projets Symfony que nous développons. Vous pouvez également créer un fichier vhost par projet afin de plus facilement les activer/désactiver au niveau d’Apache.

sudo gedit /etc/apache2/sites-available/sfProject

Puis déclarer votre vhost pour votre nouveau projet comme suit:

<VirtualHost *:80>
ServerName local.PROJECT_NAME

DocumentRoot /home/USER_NAME/workspace/PROJECT_NAME/web
<Directory /home/USER_NAME/workspace/PROJECT_NAME/web>
  Options Indexes FollowSymLinks
  AllowOverride All
</Directory>

Alias /sf /home/USER_NAME/workspace/PROJECT_NAME/lib/vendor/symfony/data/web/sf
<Directory /home/USER_NAME/workspace/PROJECT_NAME/lib/vendor/symfony/data/web/sf>
  Order Allow,Deny
  Allow from all
</Directory>

# Possible values include: debug, info, notice, warn, error, crit, alert, emerg.
LogLevel warn
ErrorLog /var/log/apache2/PROJECT_NAME_error.log
CustomLog /var/log/apache2/PROJECT_NAME_access.log combined
</VirtualHost>

Puis activer votre vhost si vous venez de le créer:

sudo a2ensite sfProject

Cette commande créer un lien symbolic depuis votre fichier /etc/apache2/sites-available/sfProject vers /etc/apache2/sites-enabled/sfProject. Pour vérifier si votre fichier est bien déclaré comme « à activer » au chargement d’apache, regarder si il est bien présent dans le dossier /etc/apache2/sites-enabled/

ls -l /etc/apache2/sites-enabled/

Vous devez avoir cette ligne

lrwxrwxrwx 1 root root 28 2010-07-05 18:24 sfProject -> ../sites-available/sfProject

Enfin pensez à redémarrer votre serveur Apache si vous avez apporté des modifications ou venez de créer le vhost ou encore de l’activer/désactiver.

sudo /etc/init.d/apache2 restart

Ajouter une entrée dans votre host

Pour pouvoir utiliser votre vhost Apache nouvellement créée il faut envoyer vos requêtes HTTP vers votre serveur (en local) avec le bon host en paramètre, pour cela le plus simple c’est de modifier votre fichier host afin d’envoyer toutes les requêtes vers votre serveur Apache.

sudo gedit /etc/hosts

puis ajouter la correspondance suivante:

127.0.0.1 local.PROJECT_NAME

Pour tester si vous avez correctement configuré votre fichier host, exécuter une simple commande ping:

ping local.PROJECT_NAME

Vous devez obtenir le résultat suivant:

64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.049 ms
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.049 ms
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.049 ms
64 bytes from localhost (127.0.0.1): icmp_seq=1 ttl=64 time=0.049 ms
...

Projet créé !

Le projet Symfony doit maintenant être créé Vous devez avoir le résultat suivant affiché dans votre navigateur à l’adresse http://local.PROJECT_NAME.

Il ne vous reste plus qu’a faire votre projet avec Symfony. Pour tout de suite vous familiariser avec les commandes, définissez l’auteur du code source

cd $HOME/workspace/PROJECT_NAME

puis

php symfony configure:author "FirstName LastName <name@mail.com>"

Voici un exemple sur comment implémenter les Behaviors via l’EventListener de Doctrine2 dans Symfony2. Dans cet exemple, nous allons mettre en place le Behavior Timestampable sur un objet Entity du model.

Récupérer les extensions de Doctrine2

Placez vous dans le dossier /vendor de votre projet Symfony

$ cd vendor

Cloner le repository git des extensions doctrine

git clone https://github.com/l3pp4rd/DoctrineExtensions.git doctrine-extensions

Vous devez avoir maintenant le dossier suivant /vendor/doctrine-extensions.

Paramétrer l’autoloader pour charger les extensions Doctrine2

Editer le fichier /app/autoload.php, et ajouter les lignes suivantes

<?php

use Symfony\Component\ClassLoader\UniversalClassLoader;
use Doctrine\Common\Annotations\AnnotationRegistry;

$loader = new UniversalClassLoader();
$loader->registerNamespaces(array(
    ...
    'Gedmo'            => __DIR__.'/../vendor/doctrine-extensions/lib',
    ...
));
...
$loader->register();

Utiliser les annotations pour définir les champs Timestampable dans votre Entity

Dans l’exemple suivant, nous allons ajouter les champs created_at et updated_at à l’objet Product.

<?php
namespace ...\Entity;

use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
...

class Product
{
    ...

    /**
     * @var datetime $created_at
     *
     * @ORM\Column(name="created_at", type="datetime")
     * @Gedmo\Timestampable(on="create")
     */
    protected $created_at;

    /**
     * @var datetime $updated_at
     *
     * @ORM\Column(name="updated_at", type="datetime")
     * @Gedmo\Timestampable(on="update")
     */
    protected $updated_at;

    ...
}

Ajouter le listener

Il faut maintenant ajouter le listener pour effectuer la mise à jour des champs created_at lors de la création, et updated_at lors de la mise à jour, et ceci automatiquement lorsque l’Entity est persisté.

Editer votre class Bundle et ajouter ou mettre à jour la fonction boot()

public function boot()
{
    $em = $this->container->get('doctrine.orm.entity_manager');
    $evm = $em->getEventManager();
    // Timestampable
    $evm->addEventSubscriber(new \Gedmo\Timestampable\TimestampableListener());
}

Voici des liens pour plus d’information sur les extensions de Doctrine2 :

http://symfony.com/doc/2.0/cookbook/doctrine/common_extensions.html
http://www.doctrine-project.org/blog/doctrine2-behavioral-extensions

Ici vous trouverez un lien vers un Bundle pour les Doctrine Extensions:
https://github.com/stof/StofDoctrineExtensionsBundle

Vous êtes bloqué pour installer le client php phpillow pour couchdb dans Symfony2 ? Vous êtes tombés au bon endroit !

Si les mots couchdb, Symfony2 et phpillow ne vous semblent pas issus du fin fond des montagnes sibériques, vous pouvez passez directement à la 2ème partie !

PHPillow, couchDB, Symfony2 : petit mémo

PHPillow est une librairie populaire permettant d’accéder facilement – et en php s’il vous plait ! – à couchDB. C’est un système de gestion de bdd orienté document (et donc NO-SQL) qui permet de répondre à des problématiques complexes avec un sgbdr classique. En effet, chacun de vos documents possède les champs que vous voulez bien lui renseigner, comme dans la vie réelle. Pour une liste de contacts par exemple, vous ne connaissez pas forcément l’adresse email, l’adresse postale, le nom, le numéro de fixe, etc… de chacun, seulement quelques infos pour chaque personne. Mais vous avez pourtant bien une base de contacts, chaque contact étant une même entité à quelques attributs près (c’est à dire que la liste des contacts forme bien une base de données).

CouchDB fonctionne sur ce principe :

Vous trouverez bientôt un article consacré à CouchDB, en attendant, pour plus d’informations, rendez vous ici.

Comment intégrer phpillow à Symfony2 ?

Pour en revenir à nos moutons, si vous avez téléchargé phpillow, vous devez avoir sous les yeux une structure assez complexe :

La partie qui nous intéresse est la partie src. C’est ici que se situe la libraire PHPillow à proprement parler, c’est à dire toutes les classes répondant à la problématique d’échange de données / flux avec couchDB. C’est le cœur du projet.

Pour rappel dans Symfony2 vos projets sont découpés de telle sorte :

• app: configuration de votre application
• src: le code source php de votre projet (=vos applications contenant vos bundles)
• vendor: les librairies tierces utilisables par Symfony
• web: racine des ressources de votre site web (images, css, js, etc..)

Phpillow est une librairie tierce, au même titre que doctrine (l’ORM installé par défaut dans Symfony2), ou encore twig (le moteur de rendu par défaut conseillé dans Symfony2). Celle-ci doit donc se placer dans le dossier vendor.

L’une des forces de Symfony2 est son autoloader, et c’est aussi là que ça se complique pour nous les amis. En effet, phpillow comporte également un autoloader situé au chemin /src/classes/autoload.php. Heureusement pour nous, nous n’avons pas à connaître le fonctionnement de cet autoloader interne car les développeurs de phpillow ont eu la délicate attention de nous fournir un bootstrap (comprenez programme d’amorçage) qui permet d’autoloader les classes automatiquement. C’est donc cette classe qu’il nous faut inclure à notre autoloader Symfony

<php
registerNamespaces(array([...]));
$loader->registerPrefixes(array([...]));
$loader->registerPrefixFallbacks(array([...]));
$loader->registerNamespaceFallbacks(array([...]));
$loader->register();

[…]

// Autoload PHPillow classes thanks to the boostrap
include __DIR__.'/../vendor/phpillow/src/bootstrap.php';

Si vous êtes toujours là, vous avez peut-être essayé (tout impatient que vous êtes) d’instancier une connexion PHPillow, persuadé qu’à partir de maintenant tout allait fonctionner

phpillowConnection::createInstance();

En faisant ceci vous avez eu droit à l’erreur vous indiquant que la classe phpillowConnection n’était pas trouvée. Bien essayé !

Bon c’est de ma faute (sifflote), je ne vous avais pas encore informé de la dernière nouveauté implémentée par php 5.3 et dans sf2 : les namespaces (i.e. espaces de nommage).

Comprendre les namespace sous Symfony2 : une étape nécessaire pour y intégrer PHPillow

Un peu complexe à appréhender, les espaces de nom sont une avancée importante dans le monde du PHP !

Pour cela, je vous renvoi à cet excellent article en 2 parties (compter 1h pour la compréhension des subtilités des namespaces, c’est primordial pour se familiariser avec le fonctionnement interne de sf2) :

• http://blog.pascal-martin.fr/post/php-5.3-namespace-1-espaces-de-noms
• http://blog.pascal-martin.fr/post/php-5.3-namespace-2-espaces-de-noms

Vous revoilà déjà ? Si vous avez bien compris, maintenant vous savez que pour vous connecter à couchdb via PHPillow vous devez écrire :

phpillowConnection::createInstance();

En effet, phpillow ne disposant pas de namespace, ses classes se trouvent dans l’espace global; celles-ci sont donc accessibles en les faisant précéder d’un antislash. Si elles avaient été dans un espace de nommage X il aurait fallu y accéder via X\ phpillowConnection

Mais cela, vous l’avez déjà bien compris n’est-ce-pas ?

Ces namespaces sont valables pour toutes les classes de votre projet ne disposant pas d’un namespace; vous devrez toujours les instancier de cette façon.

Voilà, vous savez désormais tout sur l’ajout de la librairie PHPillow sur symfony2 !

Comme mentionné en intro de cet article, Je reviendrai prochainement avec un article tout neuf sur couchDB et les quelques difficultés que l’on peut avoir à l’appréhender au début.

Bon courage à vous, vous pouvez désormais suivre cet article expliquant comment utiliser phpillow…en y apportant les modifications dues aux namespaces bien entendu !

Bonne pratique: charger une librairie tierce en créant un service dans Symfony2

Cette partie est en cours d’écriture, n’hésitez pas à revenir bientôt ! Pour être tenu au courant de cette partie, envoyez moi un petit email