[précédent]

Les contrôlleurs

Pour le moment nous avons vu qu’un contrôleur simple qui affichait un Hello World.

Comme dans de nombreux framework, le routeur va gérer la vue associée et le modèle (sous forme d’ORM complexe et d’entité). Nous allons commencer par regarder notre fichier /app/Controller/Exemple1.php qui contient un exemple d’appel de template.

class Exemple1 extends Controller {

	/**
	 * the main page
	 *
	 * @access public
	 * @return void
	 */

	public function show() {

		$aExemple = $this->model->get();

		$this->view
			 ->assigns('Exemple', $aExemple)
			 ->display();
	}
)
Pour faire simple, la fonction appelle un modèle Exemple1 ($this->model est raccourcis vers le modèle du même nom que le contrôleur) et ensuite on appelle la vue qui affiche la liste des Exemple1 qu’on a récupéré. Comme pour le modèle, si on ne définit pas la vue à appeler, le framework va automatiquement appeler la vue du même nom soit ici Exemple1.tpl.

Pour tester en réel, ce code, il nous faut se connecter sur la base de donnée et de créer la table Exemple1 comme ceci :

CREATE DATABASE demo

CREATE TABLE `Exemple1` (
     `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
     `title` varchar(150) NOT NULL,
     PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

INSERT INTO  `demo`.`Exemple1` (`id` ,`title`) VALUES (NULL ,  'test1'), (NULL ,  'test2');
Le système propose du scaffolding mais nous verrons cela plus tard.

Dès que cela est fait, il faut aller configurer la connexion de sa base de données dans le fichier /src/Demo/app/conf/Db.conf pour mettre l’utilisateur et le passeport de la base de données.

{
    "configuration": {
        "demo": {
            "type": "mysql",
            "host": "localhost",
            "db": "demo",
            "user": "root",
            "password": "",
            "tables": {
                "Exemple1": {
                    "fields": {
                        "id": {
                            "type": "int",
                            "key": "primary",
                            "null": false,
                            "undefined": true,
                            "autoincrement": true
                        },
                        "title": {
                            "type": "varchar",
                            "null": false
                        }
                    }
                }
            }
        }
    }
}
* Si vous changez de base, il faut impérativement modifier le bundles/conf/Const.php et le champ « db_conf ».

Comme vous pouvez d’ailleurs le voir, ce fichier vous permettra de créer l’ensemble des outils automatiquement à l’avenir pour utiliser vos bases de données.

Ajouter ensuite dans votre fichier de route, la nouvelle route pour tester ce contrôleur /src/Demo/app/conf/Route.conf:

"model": {
    "route": "/model",
    "controller" : "\\Venus\\src\\Demo\\Controller\\Exemple1",
    "action": "show"
}
Si vous avez réussi vous pourrez avoir dans votre navigateur :

test1 - 1

test2 - 2
2/ La fonction onConstruct permet d’initialiser le contrôleur à chaque fois qu’il est instancié :

public function onConstruct() { ; }
Une grande nouveauté de Venus est de faire des services d’injection avec l’injection de dépendance.

Voici un exemple d’injection de service que l’on peut faire dans un contrôleur :

$this->di->set('mongo', function() {
    return new Mongo();
}, true);
Le true (on peut mettre false) permet de définir si on partage le service à toutes les instances ou uniquement à cette instance. (le true valide le partage pour tous).

Dans un contrôleur, pour l’appeler, il suffit d’utiliser l’une de ces deux méthodes :

// Directement en appelant mongo, le nom de l’injection
$this->mongo->connect();

// En passant par le raccourcis de l’injection de dépendance
$this->di->get('mongo')->connect();

// En passant par le raccourcis de l’injection de dépendance avec paramètre
$this->di->set(mongo, function($param1, $param2) {
    echo $param1.' - '.$param2;
	return new Mongo();
}, true);

$mongo = $this->di->get('mongo');
$mongo('param1', 'param2');
Vous pouvez récupérer le contenu des POST envoyé par formulaire voire tester si il y a un POST envoyé de cette façon :

if ($this->request->isPost() == true) {
    $sName = $this->request->getPost("name");
    $sFirstname = $this->request->getPost("firstname");
}
Dans un car très particulier comme par exemple lors de la création de web service en Rest, vous pouvez récupérer le contenu du PUT :

$this->request->getPut();
Dans Venus Framework, il faudra utiliser un objet Request pour aller chercher un grand nombre d’information comme :

$A = new Request;
$A->request->get(‘name’) => pour chercher le $_POST[‘name’];
$A->cookies->get(‘name’) => pour chercher le $_COOKIE[‘name’];
$A->files->get(‘name’) => pour chercher le $_FILES[‘name’];
$A->headers->get(‘name’) => pour chercher le header défini par name
$A->query->get(‘name’) => pour chercher le $_GET[‘name’];
$A->server->get(‘name’) => pour chercher le $_SERVER[‘name’];
Toutes ces méthodes sont utilisées de manières identiques et autorisent également un deuxième paramètre qui est la valeur par défaut retournée si le paramètre n’est pas défini.

Venus vous propose 2 triggers sur les contrôleurs qui se lancent juste avant et juste après l’appel de l’action :

    public function beforeExecuteRoute()
    {
         // s’exécute juste avant l’appel de l’action
    }

    public function afterExecuteRoute()
    {
         // s’exécute juste après l’appel de l’action
    }
Dans cette nouvelle version de Venus Framework, l’objet Response prend de l’importance.

$response = new \Venus\lib\Response();

$response->setContent('Hello World!');
$response->setStatusCode(\Venus\lib\Response::HTTP_OK);
$response->headers->set('content-Type', 'text/html');

$response->send();
Ici, on envoie du contenu, on indique un numéro de statut, rajoutons un header HTML avant d’envoyer la totalité au navigateur avec send().

Notions avancées

Nous avions vu pour faire une action qui appelait un modèle/entité du même nom mais vous aurez besoin d’appeler d’autres modèles/entités voire vous voudrez totalement dissocier le nom du controller aux noms des modèles/entités. Cela sera probablement le cas quand vos controlleurs ne seront pas des API.

Nous allons ajouter l’utilisation d'un modèle news dans notre controller Exemple1 afin de bien comprendre la rapidité et l’efficacité du framework (c’est notre méthode recommandée mais ce n’est pas la seule méthode possible). Nous allons dans notre controller /bundles/src/Demo/app/Controller/Exemple1.php

Nous commençons par rajouter l’alias « news » de la classe modèle en haut du fichier :

namespace Venus\src\Demo\Controller;

use \Venus\src\Demo\common\Controller as Controller;
use \Venus\src\Demo\Model\news as news;
Ensuite nous créons notre raccourci d’accès au modèle dans le constructeur comme ceci :

    public function __construct() {

        $this->modelNews = function() { return new news; };

        parent::__construct();
    }
Ensuite il ne nous reste plus qu’à modifier notre action show pour appeler ce nouveau modèle :

    public function show() {

        $aExemple = $this->modelNews->get();

        $this->view
             ->assign('Exemple', $aExemple)
             ->display();
	}
Vous pouvez faire ceci directement dans le controlleur de common/ afin de donner accès à ce modèle à l'ensemble des controlleurs de votre bundle.

Des raccourcis

Les controllers proposent des raccourcis intéressants qui pourraient bien vous aider à accélérer vos développements. Voici la liste de ceux-ci et les exemples associés.

Redirect

Vous pouvez créer une redirection http rapide (ou redirection interne en cli) comme ceci :

$this->redirect($this->url->getUrl('home', array()));
Le redirect accepte également un deuxième paramètre afin de déterminer le type de redirection désirée : 301, 302, 308 ou 309. Par défaut, la fonction fait une redicrection 301.

Forward

Vous pouvez créer une redirection vers une autre action comme ceci :

$this->forward($this->url->getUrl('home', array()));
Attention : La redirection n’est pas au niveau http, donc il n’y a pas de redirection 301 mais juste que le programme se dirige vers une autre action.

Cache

Vous pouvez cacher le développement d’un contrôleur en ajoutant un élément dans le PHPDoc de la méthode comme ceci : 

    /**
    * The main menu manager
    *
    * @access public
    * @return void
    *
    * @Cache(maxage=12)
    */

    public function show() {
Raccourcis

Voici des raccourcis automatiquement propose à tous les contrôleurs que nous verrons plus en détail par la suite : 

$this->form = function() { return new Form(); };
$this->security = function() { return new Security(); };
$this->router = function() { return new Router; };
$this->mail = function() { return new Mail; };
$this->session = function() { return new Session; };
$this->translator = function() { return new I18n; };
Vous pouvez automatiquement envoyer des erreurs HTTP dans les contrôleurs afin de gérer vous-mêmes des retours HTTP : 

$this->NotFound();
$this->Forbidden();
[suivant]