Jobeet ZF2 - Jour 3 - Le modèle de données

Après avoir préparé le squelette de projet et présenté les différentes exigences du projet Jobeet, nous allons enfin ouvrir notre éditeur de code. Nous allons définir le modèle de données de Jobeet, mettre en place des intéractions avec la base de données et construire le premier module de l'application.

Contrairement au framework Symfony, qui génère beaucoup de chose à notre place, nous allons devoir écrire un peu de code PHP.

Modification du 17/10/2012:
J'ai supprimer du script SQL la clé étrangère id_user de la table Job. Pour les prochains cours, nous nous concentrerons uniquement sur les tables Job et Category. Les utilisateurs reviendront plus tard.

Le modèle relationnel

Les différentes histoires d'utilisateurs, que nous avons vu dans le jour 2, nous présentent les objets principaux de notre projet: les emplois, les catégories et les utilisateurs.

Diagramme

La base de données

Pour stocker les emplois, les catégories et les utilisateurs, nous avons besoin d'une base de données relationnelle. Zend Framework 2 permet de se connecter à différents moteur de base de données (MySQL, PostgreSQL, SQLite, ...).

Pour notre projet, nous allons utiliser MySQL. Créons maintenant notre base de  données.

mysqladmin -uroot -p create jobeet

Enter password: your-root-password ## Votre mot de passe ne sera pas visile

Nous allons créer un utilisateur mysql qui aura uniquement accès à la base jobeet.

Connectons-nous à MySQL et créons notre utilisateur:

mysql -uroot -p jobeet   # Le mot de passe de l'utilisateur MySQL root vous sera demandé

GRANT ALL PRIVILEGES 
       ON jobeet.* 
       TO 'jobeet_user'@'localhost'
       IDENTIFIED BY 'votre_password' 
       WITH GRANT OPTION;

Explication:

• Ligne 1: Nous donnons tous les droits
• Ligne 2: sur toutes les tables de la base de données jobeet
• Ligne 3: pour l'utilisateur jobeet_user  (vous pouvez choisir un autre nom d'utilisateur ici).
• Ligne 4: L'utilisateur aura comme mot de passe 'votre_passeword' (à définir ici')
• Attention: Le mot de passe de l'utilisateur sera crypté par MySQL, et ne sera pas visible en clair
• Ligne 5: L'utilisateur pourra créer d'autres utilisateurs avec l'option GRANT

Les tables SQL

Les données seront stockées dans notre base MySQL. Créeons maintenant les différentes tables dont nous avons besoin.

CREATE  TABLE IF NOT EXISTS `category`
(
  `id_category` INT NOT NULL AUTO_INCREMENT ,
  `name` VARCHAR(100) NULL ,
  PRIMARY KEY (`id_category`)
) ENGINE = InnoDB;

CREATE  TABLE IF NOT EXISTS `job`
(
  `id_job` INT NOT NULL AUTO_INCREMENT ,
  `id_category` INT NOT NULL ,
  `type` VARCHAR(255) NULL ,
  `company` VARCHAR(255) NOT NULL ,
  `logo` VARCHAR(255) NULL ,
  `url` VARCHAR(255) NULL ,
  `position` VARCHAR(255) NOT NULL ,
  `location` VARCHAR(255) NOT NULL ,
  `description` TEXT NOT NULL ,
  `how_to_play` TEXT NOT NULL ,
  `is_public` TINYINT(1) NOT NULL ,
  `is_activated` TINYINT(1) NOT NULL ,
  `email` VARCHAR(255) NOT NULL ,
  `created_at` TIMESTAMP NOT NULL ,
  `updated_at` TIMESTAMP NOT NULL ,
  PRIMARY KEY (`id_job`) ,
  CONSTRAINT `fk_job_category` FOREIGN KEY (`id_category`)
    REFERENCES `category` (`id_category`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION
) ENGINE = InnoDB;

CREATE INDEX `fk_job_category2` ON `job` (`id_category` ASC);

La base de données est prête!

Grâce à ZF2, nous n'avons pas besoin d'écrire directement nos requêtes SQL pour récupérer des enregistrements de la base de données. Mais contrairement à Symfony , qui permet de générer vos modèles automatiquement, nous allons devoir écrire nous-même le code de nos objets.

Voyons comment Zend Framework 2 nous permet de "communiquer" avec MySQL.

Un peu de code

Nous allons mettre tout notre code dans un nouveau Module. Celui-ci contiendra nos modèles, nos controlleurs, nos formulaires, nos vues et de la configuration.

Pour charger et configurer un module, Zend Framework 2 à un ModuleManager.

Ce ModuleManager va chercher le fichier Module.php présent à la racine du module (module/Front) et s'attend à trouver une classe /Front/Module. Autrement dit, les classes à l'intérieur d'un module donné auront un namespace (espace de nom) du nom du module (qui est le nom du répertoire du module).

Editons le fichier Module.php

namespace Front;

class Module
{
    public function getAutoloaderConfig()
    {
        return array(
            'Zend\Loader\ClassMapAutoloader' => array(
                __DIR__ . '/autoload_classmap.php',
            ),
            'Zend\Loader\StandardAutoloader' => array(
                'namespaces' => array(
                    __NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__,
                ),
            ),
        );
    }

    public function getConfig()
    {
        return include __DIR__ . '/config/module.config.php';
    }
}

Le ModuleManager appelera les méthodes getAutoloaderConfig() et getConfig() automatiquement pour nous.

Autochargement des fichiers

Notre méthode getAutoloaderConfig() retourne un tableau qui est compatible avec l'AutoloaderFactory de Zend Framework 2. Nous avons besoin d'un fichier autoload_classmap.php (voir la documentation officielle pour ClassmapAutoloader et pour StandardAutoloader pour plus d'information).

En développement, nous n'avons pas besoin de remplir ce fichier autoload_classmap.php.

Nous allons donc lui faire retourné un tableau vide

// dans module/Front/autoload_classmap.php:
    return array();

Configuration

Une fois l'autoloader enregistré, jettons au coup d'oeil à la méthode getConfig() dans Front/Module. Cette méthode charge simplement le fichier /config/module.config.php

Créons le fichier de configuration suivant pour le module Front

// module/Front/config/module.config.php:
return array(
    'controllers' => array(
        'invokables' => array(
            'Front\Controller\Category' => 'Front\Controller\CategoryController',
            // on ajoutera ici les différents controlleurs
        ),
    ),
    // On indique ici où sont les vues du module
    'view_manager' => array(
        'template_path_stack' => array(
            'front' => __DIR__ . '/../view',
        ),
    ),
);

Le ServiceManager passera les informations de configuration aux composants adéquats.

Les fichiers Model

Plusieurs composants du framework permettent d’implémenter la logique métier:

• Une approche est d'avoir des classes Model représentant chaque entités de votre application puis d'utiliser des objets de mapping pour charger et enregistrer les entités dans la base de données: cette approche implémente le design pattern Table Data Gateway.
• Une autre approche est d'utiliser un ORM, tel Doctrine ou Propel: nous verrons cette approche hors tutoriel

Nous utiliserons donc la première approche. Nous allons créer une classe CategoryTable, étendant Zend\Db\TableGateway\TableGateway. Chaque objet sera un objet Category (appelé aussi Entité)

Voici le code de la classe Category:

// module/Front/src/Front/Model/Category.php:
namespace Front\Model;

class Category
{
    public $idCategory;
    public $name;
    
    public function exchangeArray($data)
    {
        $this->idCategory = (isset($data['id_category'])) ? $data['id_category'] : null;
        $this->name = (isset($data['name'])) ? $data['name'] : null;
    }
}

Notre entité Category est une simple classe PHP. Nous y ajoutons une méthode exchangeArray(). Cette méthode est nécessaire pour faire fonctionner cette classe Category avec AbstractTableGateway: Elle copie simplement les données du tableau passé en paramètre aux propriété de notre entité.

Ensuite, nous devons étendre Zend\Db\TableGateway\AbstractTableGateway pour créer notre propre classe CategoryTable dans le répertoire Model de notre module.

namespace Front\Model;

use Zend\Db\Adapter\Adapter;
use Zend\Db\ResultSet\ResultSet;
use Zend\Db\TableGateway\AbstractTableGateway;

class CategoryTable extends AbstractTableGateway
{
    // Table name in database
    protected $table ='category';

    public function __construct(Adapter $adapter)
    {
        $this->adapter = $adapter;
        $this->resultSetPrototype = new ResultSet();
        $this->resultSetPrototype->setArrayObjectPrototype(new Category());
        $this->initialize();
    }

    public function fetchAll()
    {
        $resultSet = $this->select();
        return $resultSet;
    }

    public function getCategory($id)
    {
        $id  = (int)$id;
        $rowset = $this->select(array('id_category' => $id));
        $row = $rowset->current();

        if (!$row) {
            throw new \Exception("Could not find row $id");
        }

        return $row;
    }

    public function saveCategory(Category $category)
    {
        $data = array(
            'id_category' => $category->idCategory,
            'name'  => $category->name
        );

        $id = (int)$category->id_category;

        if ($id == 0) {
            $this->insert($data);
        } elseif ($this->getCategory($id)) {
            $this->update(
                $data,
                array(
                    'id_category' => $id,
                )
            );
        } else {
            throw new \Exception('Form id does not exist');
        }
    }

    public function deleteCategory($id)
    {
        $this->delete(array('id_category' => $id));
    }
}

Quelques explications sur le code que nous avons écrit.

D'abord, nous indiquons le nom de la table dans la propriété protégée $table.

Ensuite, le constructeur: il accepte en paramètre en Zend\Db\Adapter\Adapter.

Nous indiquons ensuite comment le ResultSet doit être créé, et qu'il doit utiliser l'objet Category. Les classes TableGateway utilise le pattern Prototype pour la création de resultset et d'entités: cela signifie qu'au lieu d’instancier un objet quand on en a besoin, le système clone un objet précédemment instancié.

Les autres méthodes sont des méthodes d'aide, que nous utiliserons plus tard pour interagir avec la base de données: fetchAll() renvoie toutes les catégories de la base sous forme de ResultSet, getCategory() retourne un enregistrement de type Category, saveCategory() crée ou met à jour un enregistrement et deleteCategory supprime complètement l'enregistrement. Le code de ces méthodes est pour vous, je l'espère, assez explicite.

Utilisation du ServiceManager

Afin de toujours utiliser la même instance de notre CategoryTable, nous allons utiliser le ServiceManager pour définir comment en créer une. Cela se fait assez facilement dans la classe Module de notre module: nous allons créer une méthode getServiceConfig() qui sera automatiquement appelé par le ModuleManager. Nous serons ainsi capable de récupérer cette instance dans nos controleurs quand nous en aurons besoin.

// module/Front/Module.php:
namespace Front;

// Ajouter ici:
use Front\Model\CategoryTable;

class Module
{
    [...]

    // Ajouter cette méthode après getAutoloaderConfig() et getConfig():
    public function getServiceConfig()
    {
        return array(
            'factories' => array(
                'Front\Model\CategoryTable' =>  function($sm) {
                    $dbAdapter = $sm->get('Zend\Db\Adapter\Adapter');
                    $table     = new CategoryTable($dbAdapter);
                    return $table;
                },
            ),
        );
    }
}

Nous arrivons à la fin du jour 3 de ce tutoriel Jobeet Pour Zend Framework 2.

Avant d'accèder au jour 4, je vous laisse écrire (comme exercice) les classes Job, JobTable, User et UserTable.
Avant d'accéder au jour 4, ajoutons les classes Job et JobTable

// module/Front/src/Front/Model/Job.php
namespace Front\Model;

class Job
{
    public $idJob;
    public $idCategory;
    public $idUser;
    public $type;
    public $company;
    public $logo;
    public $url;
    public $position;
    public $location;
    public $description;
    public $howToPlay;
    public $isPublic;
    public $isActivated;
    public $email;
    public $createdAt;
    public $updatedAt;
    
    public function exchangeArray($data)
    {
        $this->idJob = (isset($data['id_job'])) ? $data['id_job'] : null;
        $this->idCategory = (isset($data['id_category'])) ? $data['id_category'] : null;
        $this->idUser = (isset($data['id_user'])) ? $data['id_user'] : null;
        $this->type = (isset($data['type'])) ? $data['type'] : null;
        $this->company = (isset($data['company'])) ? $data['company'] : null;
        $this->logo = (isset($data['logo'])) ? $data['logo'] : null;
        $this->url = (isset($data['url'])) ? $data['url'] : null;
        $this->position = (isset($data['position'])) ? $data['position'] : null;
        $this->location = (isset($data['location'])) ? $data['location'] : null;
        $this->description = (isset($data['description'])) ? $data['description'] : null;
        $this->howToPlay = (isset($data['how_to_play'])) ? $data['how_to_play'] : null;
        $this->isPublic = (isset($data['is_public'])) ? $data['is_public'] : null;
        $this->isActivated = (isset($data['is_activated'])) ? $data['is_activated'] : null;
        $this->email = (isset($data['email'])) ? $data['email'] : null;
        $this->createdAt = (isset($data['created_at'])) ? $data['created_at'] : null;
        $this->updatedAt = (isset($data['updated_at'])) ? $data['updated_at'] : null;
    }
}


// module/Front/src/Front/Model/JobTable.php
namespace Front\Model;

use Zend\Db\Sql\Select;
use Zend\Db\Adapter\Adapter;
use Zend\Db\ResultSet\ResultSet;
use Zend\Db\TableGateway\AbstractTableGateway;

class JobTable extends AbstractTableGateway
{
    protected $table ='job';

    public function __construct(Adapter $adapter)
    {
        $this->adapter = $adapter;
        $this->resultSetPrototype = new ResultSet();
        $this->resultSetPrototype->setArrayObjectPrototype(new Job());
        $this->initialize();
    }

    public function fetchAll()
    {
        $resultSet = $this->select();
        return $resultSet;
    }
    
    public function getJob($id)
    {
        $id  = (int)$id;
        $rowset = $this->select(array('id_job' => $id));
        $row = $rowset->current();

        if (!$row) {
            throw new \Exception("Could not find row $id");
        }

        return $row;
    }

    public function saveJob(Job $job)
    {
        $data = array(
            'id_job' => $job->idJob,
            'id_category' => $job->idCategory,
            'id_user' => $job->idUser,
            'type' => $job->type,
            'company' => $job->company,
            'logo' => $job->logo,
            'url' => $job->url,
            'position' => $job->position,
            'location' => $job->location,
            'description' => $job->description,
            'howToPlay' => $job->howToPlay,
            'isPublic' => $job->isPublic,
            'isActivated' => $job->isActivated,
            'email' => $job->email,
            'createdAt' => $job->createdAt
        );

        $id = (int)$job->idJob;

        if ($id == 0) {
            $this->insert($data);
        } elseif ($this->getJob($id)) {
            $this->update(
                $data,
                array(
                    'id_job' => $id,
                )
            );
        } else {
            throw new \Exception('Form id does not exist');
        }
    }

    public function deleteJob($id)
    {
        $this->delete(array('id_job' => $id));
    }
}

N'oubliez pas d'ajouter la classe JobTable dans le fichier Module.php

// module/Front/Module.php:
namespace Front;

// Ajouter ici:
use Front\Model\CategoryTable;

class Module
{
    [...]

    public function getServiceConfig()
    {
        return array(
            'factories' => array(
                'Front\Model\CategoryTable' =>  function($sm) {
                    $dbAdapter = $sm->get('Zend\Db\Adapter\Adapter');
                    $table     = new CategoryTable($dbAdapter);
                    return $table;
                },
                // On ajoute JobTable ici
                'Front\Model\JobTable' =>  function($sm) {
                    $dbAdapter = $sm->get('Zend\Db\Adapter\Adapter');
                    $table     = new JobTable($dbAdapter);
                    return $table;
                },
            ),
        );
    }
}

Télécharger les source du jour 3 sur mon compte Github

Jour 4 - Controller et Vue

Il faudra que je reprenne ce tutoriel un de ces jours. On m'a fait remarqué la forte ressemble avec un article qui m'a servi de suppport. Cette article étant un de mes débuts de blogger, je vois qu'il n'est pas évident de "s'inspirer de..." sans "plagier". En tout cas, merci à Philippe Peso, pour l'excellent tuto de Rob Allen. Pour le lire, ca se passe sur developpez.com.